Commit Graph

6175 Commits

Author SHA1 Message Date
pranayr710
afa5b1b5f3 core: saturate cv::absdiff on CV_64S instead of letting it return a negative
getAbsdiffFunc_() documents that a signed depth has two outputs: R == T, the saturating |a-b| kept
in the signed range, which is the depth cv::absdiff returns; and R == the unsigned type of the same
width. CV_8S, CV_16S and CV_32S each have both. CV_64S only had the unsigned one, so the signed
form fell through to a path that wraps:

    absdiff(INT64_MIN, 0)         -> -9223372036854775808
    absdiff(INT64_MIN, INT64_MAX) -> -1

at every length, scalar included, in a CV_64S destination. The narrower depths all saturate at
their maximum: absdiff(INT_MIN, INT_MAX) on CV_32S is INT_MAX.

The missing row now uses EwAbsdiffS, whose scalar step gains a 64-bit overload. The generic one
widens into the work type, which the narrower depths have (short, int, int64_t) and 64-bit does not,
and |INT64_MIN - b| does not fit in int64_t anyway. The difference is therefore taken in uint64,
which is exact for every pair, and clamped to INT64_MAX. The narrower depths reach that overload
only through their int64 work type, where |a - b| is at most 2^32 and the clamp is a no-op.

Core_AbsdiffSigned checks both properties - never negative, and saturating at the depth's maximum -
across CV_8S, CV_16S, CV_32S and CV_64S.
2026-10-21 09:49:45 +03:00
Vadim Pisarevsky
6a5623e271 Merge pull request #30061 from vpisarev:fft_vector
vectorized and parallel DFT/DCT + matchTemplate - #30061

(Made with a help from Claude Code Fable 5.1)

## Summary

This PR replaces the scalar 1D DFT/DCT kernels in `modules/core/src/dxt.cpp` with a new engine
built on universal intrinsics and compiled per ISA through `ocv_add_dispatched_file`, and makes
the 2D transforms, the `DFT_ROWS`/`DCT_ROWS` batches and `matchTemplate` (`crossCorr`) multi-threaded.

The public API, the output formats (CCS packing of real spectra, `DFT_COMPLEX_OUTPUT` layout,
DCT ordering and normalization) and the IPP/OpenCL paths are unchanged. Only floating-point
rounding may differ (the new twiddle tables are more accurate than the old recurrence-generated
ones, so the error goes down, not up).

Measured on Apple M4 Max (16 cores, NEON), macOS 26.5.x, Xcode 26.6, Release build
(`-O3`, no IPP). All numbers are the minimum over repeated runs, `5.x` vs this PR.

## Changes

### New 1D engine (`dxt.hpp`, `dxt.simd.hpp`, `dxt.cpp`)

- **Split re/im layout.** The input pass gathers the data into separate `re[]`/`im[]` workspace
  arrays; all middle stages operate on the split arrays, so a complex multiplication is four
  independent vector FMAs with no lane shuffling. The output pass interleaves back (or packs the
  CCS / DCT layout) with the scaling fused in.
- **Mixed-radix decimation-in-time with a fused first stage.** The plan chooses the first stage
  (radix 1/2/4/8, twiddle-free, fused with the gather and the digit-reversal permutation) from
  the power of two in the length, then radix-4 stages, then radix-3, radix-5 and a generic odd
  radix. There are no radix-2 middle stages.
- **Vectorized butterflies with universal intrinsics** (`v_float32`/`v_float64`, VLA-safe): one
  flat loop per stage with a single clamped counter for both the data and the twiddle offsets
  (the back-off clamp handles spans that are not multiples of the vector width; such stages run
  out of place, ping-ponging between two workspace pairs, the others run in place).
- **Vectorized first stage.** The radix-2/4/8 first stage reads the input columns contiguously
  (`v_load_deinterleave`), runs the small DFT in registers and scatters the outputs of every
  lane with one 4-channel interleaved store. Only odd lengths use a scalar table-driven gather.
- **Vectorized edge passes**: interleave/deinterleave, the real-FFT untangling in both directions
  (with `v_reverse` for the mirrored half), DCT-II post-twiddle and DCT-III pre-twiddle, the
  Makhoul permutations.
- **Inverse = conjugation trick**: the middle stages are direction-free and use forward twiddles
  only; the inverse conjugates on the gather and negates the imaginary scale on the output.
- **Immutable plan + per-executor workspace, zero allocations per transform.** The plan
  (radix sequence, permutation table, per-stage split twiddle tables) is built once in `init()`
  and shared by all rows of a batch; every executor owns a workspace. Twiddles are generated in
  double precision from a two-level exact table (a few ulps, much cheaper to build than the old
  N-point recurrence, which matters because `cv::dft()` builds a plan on every call).
- **Per-ISA dispatch**: `ocv_add_dispatched_file(dxt SSE2 AVX2 AVX512_ICL RVV)`; the kernels are
  reached through a function-pointer table resolved once per depth, following the pattern of
  `arithm.simd.hpp` / `warp_kernels.simd.hpp`. The plan is built with the vector width of the
  dispatched kernels (never with the baseline `VTraits`).
- The legacy scalar engine, `DFTInit`, the SSE3 `DFT_VecR*` butterflies and the `noPermute`/
  `factors[0] >>= 1` machinery are removed (−1400 lines). The legacy `cv_hal_dft` hook (which
  took the old tables) is no longer called from the 1D path; the in-tree RISC-V HAL
  implementation of it will be updated in a separate PR.

### Parallelism

- `crossCorr` (`matchTemplate`): the correlation tiles are independent and are now distributed
  with `parallel_for_`; every worker creates its DFT buffers and `DFT2D` contexts once per range.
  (The tile loop had been sequential since the C++ rewrite in 2010, which dropped the OpenMP
  pragma of `icvCrossCorr`.)
- 2D DFT/DCT and `DFT_ROWS`/`DCT_ROWS` batches: the row pass, the column pass and the DCT line
  loop distribute their lines over threads; the 1D plan is shared, each worker allocates its
  workspace once per range. The number of stripes is derived from the N log N cost, so a 256x256
  transform stays on the calling thread and 1024x1024 gets ~20 stripes. Nested calls (the 2D DFTs
  inside the parallel `crossCorr` tiles) are serialized by `parallel_for_` itself.
- The column pass copies columns in batches (`CopyFromColumns`/`CopyToColumns`, 4..16 adjacent
  columns copied row by row into contiguous buffers sized to stay within 128 KB) instead of two
  at a time: with power-of-two row steps the old strided copies aliased in the cache and took
  60-70% of the 2D time.

### Tests

- `Core_DFT.sweep_1d`, `Core_DCT.sweep_1d`: every 5-smooth length up to 2048 plus odd, prime and
  "awkward" lengths, both depths, C2C forward/inverse, R2C (CCS and complex output), C2R (CCS and
  complex input), DCT/IDCT, in-place, column vectors, round trips; compared against the naive
  O(N^2) references of `test_dxt.cpp` with a tolerance of `32*eps*(log2(N) + 2 + maxfactor/16)`.
- `Core_DFT.sweep_rows`: `DFT_ROWS` batches sharing one plan.
- `Core_DFT.nonzero_rows`: 2D transforms with `nonzero_rows` (previously uncovered).
- `Core_DFT.parallel_large`: large 2D / rows / DCT transforms, multi-threaded result vs the
  single-threaded one.
- The naive DCT reference reduces the angle exactly before `cos()` (its accuracy was limiting
  the comparison for n > 100 in double precision).
- Perf: `perf_dft.cpp` gains 1D row/column cases for `dft` and `dct`.
- Existing `opencv_test_core` (incl. `Core_DFT*`, `Core_DCT*`, `Core_MulSpectrums`,
  `Core_DivSpectrums`) and `opencv_test_imgproc` (phaseCorrelate, matchTemplate, filter2D) pass;
  the x86-64 build (SSE3 baseline + SSE4.1/AVX2/AVX512_ICL dispatch) passes the DFT/DCT tests
  under Rosetta 2 (AVX2/AVX-512 paths compile-checked only on this machine).

## Performance

### 1D transforms (single row, one thread), microseconds

`C2C` = complex-to-complex, `R2C` = real-to-CCS, `C2R` = CCS-to-real (inverse, scaled),
`32`/`64` = float/double.

| n | C2C32 | C2C64 | R2C32 | C2R32 | R2C64 | DCT32 | IDCT32 | DCT64 |
|---|---|---|---|---|---|---|---|---|
| 256 | 0.82 → 0.55 | 0.86 → 0.74 | 0.67 → 0.53 | 0.63 → 0.52 | 0.64 → 0.56 | 0.88 → 0.56 | 0.88 → 0.56 | 0.90 → 0.66 |
| 1000 | 3.84 → 1.70 | 4.08 → 2.58 | 2.86 → 1.36 | 2.88 → 1.38 | 2.77 → 1.74 | 3.95 → 1.69 | 4.02 → 1.72 | 3.97 → 2.15 |
| 1024 | 3.25 → 1.65 | 3.44 → 2.40 | 2.46 → 1.23 | 2.35 → 1.27 | 2.42 → 1.59 | 3.57 → 1.57 | 3.51 → 1.59 | 3.45 → 2.02 |
| 4096 | 14.9 → 6.4 | 16.4 → 11.5 | 10.7 → 4.3 | 10.2 → 4.5 | 11.0 → 6.9 | 15.4 → 6.0 | 15.3 → 6.0 | 17.0 → 9.5 |
| 4725 (3³·5²·7) | 27.5 → 17.2 | 29.4 → 24.1 | 28.2 → 16.4 | 29.8 → 18.3 | 30.3 → 24.7 | – | – | – |
| 65536 | 350 → 273 | 411 → 494 | 223 → 136 | 274 → 139 | 251 → 249 | 318 → 167 | 299 → 159 | 372 → 320 |

Each `cv::dft()` call builds its plan anew; at n = 4096 the plan takes ~1.9 µs of the 6.4 µs
(the old code spent ~4 µs of 14.9 on its tables). For n = 65536 both versions are bound by the
memory traffic of the out-of-cache data, and C2C64 gets slightly slower (the split layout needs
one more pass over 1 MB of data; a plan cache or larger radices could recover this later).

### 2D transforms, single thread, microseconds

| size | C2C32 | R2C32 | C2R32 | R2C64 | DCT32 | IDCT32 | R2C32 rows |
|---|---|---|---|---|---|---|---|
| 256×256 | 297 → 140 | 162 → 75 | 165 → 77 | 178 → 126 | 259 → 166 | 290 → 174 | 72 → 29 |
| 512×512 | 1660 → 569 | 765 → 306 | 723 → 317 | 896 → 551 | 1381 → 946 | 1377 → 957 | 303 → 125 |
| 480×640 | 1555 → 715 | 895 → 377 | 918 → 392 | 978 → 677 | 1248 → 707 | 1262 → 695 | 389 → 147 |
| 1024×1024 | 7508 → 2625 | 3781 → 1387 | 3883 → 1398 | 4964 → 3201 | 6438 → 4556 | 6805 → 4583 | 1341 → 516 |
| 1080×1920 | 13141 → 5543 | 7143 → 2880 | 7269 → 2970 | 7770 → 5348 | 9735 → 5190 | 9477 → 5381 | 3116 → 1192 |
| 2048×2048 | 38151 → 16822 | 18381 → 6973 | 18784 → 7294 | 25146 → 17476 | 30291 → 21631 | 30540 → 22003 | 5809 → 2242 |

### 2D transforms, default thread count (16), microseconds

| size | C2C32 | R2C32 | C2R32 | R2C64 | DCT32 | IDCT32 | R2C32 rows |
|---|---|---|---|---|---|---|---|
| 256×256 | 309 → 138 | 157 → 75 | 161 → 77 | 174 → 126 | 265 → 167 | 293 → 170 | 71 → 29 |
| 512×512 | 1660 → 162 | 785 → 155 | 788 → 160 | 866 → 256 | 1410 → 235 | 1366 → 228 | 303 → 41 |
| 480×640 | 1531 → 178 | 895 → 142 | 916 → 141 | 957 → 222 | 1241 → 172 | 1248 → 173 | 393 → 46 |
| 1024×1024 | 7495 → 381 | 3755 → 274 | 3767 → 269 | 4875 → 478 | 6323 → 650 | 6583 → 630 | 1343 → 94 |
| 1080×1920 | 12905 → 681 | 7131 → 403 | 7240 → 382 | 7760 → 657 | 9673 → 605 | 9513 → 607 | 3124 → 143 |
| 2048×2048 | 38155 → 1481 | 18324 → 826 | 18559 → 857 | 24861 → 1776 | 30120 → 2592 | 30741 → 2734 | 5890 → 274 |

(5.x is single-threaded for all of these; 256×256 stays single-threaded in the new code by design.)

### matchTemplate (`opencv_perf_imgproc`, `*matchTemplate*`), milliseconds

Whole suite (156 cases): 921 → 284 ms. Selected cases (8-bit image, 16×16 template unless noted):

| image, template | SQDIFF | SQDIFF_NORMED | CCORR | CCORR_NORMED | CCOEFF | CCOEFF_NORMED |
|---|---|---|---|---|---|---|
| 128×128 | 0.15 → 0.12 | 0.14 → 0.12 | 0.09 → 0.05 | 0.13 → 0.09 | 0.11 → 0.08 | 0.13 → 0.10 |
| 320×240 | 0.99 → 0.52 | 1.09 → 0.58 | 0.79 → 0.23 | 0.96 → 0.42 | 0.93 → 0.38 | 1.02 → 0.53 |
| 640×480 | 3.19 → 1.17 | 3.35 → 1.22 | 2.27 → 0.29 | 3.12 → 1.04 | 2.94 → 0.90 | 3.43 → 1.38 |
| 800×600 | 5.86 → 1.64 | 5.61 → 1.77 | 4.11 → 0.34 | 5.48 → 1.53 | 5.19 → 1.28 | 5.82 → 2.04 |
| 1024×768 | 9.73 → 2.72 | 9.59 → 2.90 | 6.88 → 0.48 | 9.11 → 2.45 | 8.44 → 2.05 | 9.84 → 3.44 |
| 1280×1024 | 14.92 → 4.33 | 15.01 → 4.58 | 10.70 → 0.64 | 14.31 → 3.97 | 13.40 → 3.33 | 15.37 → 5.58 |
| 1280×1024, 1260×1000 | 13.06 → 7.90 | 13.08 → 7.74 | 10.75 → 3.58 | 12.23 → 5.03 | 11.11 → 3.94 | 12.03 → 5.05 |

`TM_CCORR` is now dominated by the (still single-threaded) `integral()` and normalization passes
in the other methods; those are candidates for a follow-up.

## Notes for reviewers

- `modules/core/src/dxt.hpp` documents the engine layout; the plan builder (`DftPlan::build`)
  and the driver (`runDft`) are in `dxt.cpp`, the kernels in `dxt.simd.hpp`.
- Stages whose span is smaller than the vector width run scalar (on NEON this only affects
  lengths of the form 2·odd; on AVX2/AVX-512 also the first radix-4 stage of 4^k lengths);
  handling them with narrower fixed-width vectors is a possible follow-up.
- A radix-8 middle stage was implemented and measured slower on NEON than two radix-4 stages
  (register pressure), so it is not included.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-21 09:10:35 +03:00
Shiven Solanki
8871a3408a Merge pull request #30386 from sshivensolanki:fix-ocl-convert-saturation
core: saturate OpenCL conversions to CV_32U, CV_64U and CV_64S - #30386

Fixes #30385

### Problem

`ocl::convertTypeStr()` uses `ddepth >= CV_32F` / `sdepth >= CV_32F` to mean "is a float type". The 5.x integer depths are numbered above `CV_32F`, so conversions to `CV_32U`, `CV_64U` and `CV_64S` are emitted without `_sat` (and without `_rte` from float sources). `UMat::convertTo` and other OpenCL kernels using `convertTypeStr()` then wrap around instead of saturating, e.g. `-5` → `CV_32U` gives `4294967291` instead of `0`.

### Fix

In `convertTypeStr()`:

- use `CV_IS_FLOAT_TYPE(ddepth)` / `CV_IS_FLOAT_TYPE(sdepth)` instead of comparing with `CV_32F`;
- for float → integer, always use `_sat_rte`, matching the CPU's saturating `cvRound` since #30007 (was: `_sat` only below `CV_32S`).

This also fixes `CV_64S`/`CV_64U`/`CV_32U` → `CV_32S` in `UMat::convertTo`, which converts through that float → `CV_32S` path. Conversions between the 4.x depths are otherwise unchanged.

### Tests

New `OCL_MatrixOperation/ConvertToSaturate.Accuracy` compares `UMat::convertTo` with `Mat::convertTo` in the destination type for `CV_8S`/`CV_16S`/`CV_32S`/`CV_64S`/`CV_32F` → `CV_32S`/`CV_32U`/`CV_64U`/`CV_64S`, with values that need clamping or rounding. On current 5.x it fails for 10 of the pairs; with this patch it passes. All `OCL_*` and `convertTo` tests in `opencv_test_core` pass locally (7522 tests).

`CV_64U` sources are left out for now: the CPU path for `CV_64U` → `CV_64S` is a bit copy until #30206 lands.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
2026-10-21 08:08:29 +03:00
Abhishek Gola
9123a3c209 Merge pull request #30393 from sshivensolanki/fix-ocl-compare-scalar
core: fix OpenCL compare with a scalar for CV_32U, CV_64U and CV_64S
2026-10-20 16:55:16 +05:30
Abhishek Gola
355813ccd6 Merge pull request #30375 from sshivensolanki/fix-ocl-typetostr-fp8
core: fix out-of-bounds lookups in ocl::typeToStr tables for 5.x depths
2026-10-20 14:37:45 +05:30
Abhishek Gola
2e1e9e6f5f Merge pull request #30345 from Prasadayus/fix/neon-dotprod-overflow
core: fix int16 overflow in NEON and MSA v_dotprod_expand for int8
2026-10-20 12:40:51 +05:30
Abhishek Gola
56d8dcb149 Merge pull request #30206 from pranayr710/fix/convert-64u-signed
core: stop convertTo() treating CV_64U as signed
2026-10-20 09:39:40 +05:30
Shiven Solanki
550933af8f Merge branch '5.x' into fix-ocl-compare-scalar 2026-10-19 21:44:11 +08:00
Shiven Solanki
4d190b202f Merge pull request #30383 from sshivensolanki:fix-ocl-arithm-16bf
core: fall back to CPU for CV_16BF in OpenCL arithmetic - #30383

Fixes #30382

### Problem

`arithm_op()` calls the OpenCL path directly and relies on it returning `false` when it can't run. `ocl_arithm_op()` and `ocl_binary_op()` don't check the depth and pass it to `ocl::typeToStr()`, which asserts for `CV_16BF`. So `add`, `subtract`, `multiply`, `divide`, `absdiff`, `min`, `max`, `addWeighted` and add-with-scalar on a `CV_16BF` `UMat` throw, while the same calls on a `Mat` work.

### Fix

In `modules/core/src/arithm.cpp`, add `noOclType()` for the depths that have no OpenCL type (`CV_16BF`, `CV_Bool`, `CV_8F_E4M3FN`, `CV_8F_E4M3FNUZ`) and return `false` for them:

- `ocl_arithm_op()`: if any of the source, destination or working depths has no OpenCL type.
- `ocl_binary_op()`: if the source depth has no OpenCL type and the op is not bitwise (bitwise ops use `memopTypeToStr()`, not `typeToStr()`).

The CPU path then handles them, as it already does for `Mat`. Same approach as #30252 for `threshold`.

### Tests

New `OCL_Arithm.bf16_falls_back_to_cpu` runs the 9 ops on `CV_16BF` `Mat` and `UMat` inputs and checks the results are identical. It fails on current 5.x with the `typeToStr` assertion and passes with this patch. All `OCL_Arithm*`, `Core_Arithm*`, the CPU add/sub/mul/div/min/max/absdiff/addWeighted tests and the `UMat` tests pass locally (7933 tests).

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
2026-10-19 16:21:19 +03:00
Prasadayus
0f990c5333 fix int16 overflow in MSA v_dotprod_expand for int8 2026-10-19 14:49:30 +05:30
Shiven Solanki
91d74fe6e8 core: add CV_64U, CV_64S and CV_32U to ocl memop/vecop type tables 2026-10-19 15:20:58 +08:00
Alexander Smorkalov
2f155b7c17 Merge pull request #30380 from harjothkhara:codex/opencv-27862-2026-10-18
core: fix Mat vector constructor docs for 1D matrices 🤖🤖🤖
2026-10-19 09:45:12 +03:00
Vincent Rabaud
ec8d521e11 Merge pull request #30286 from vrabaud:fuzztest_fixes
Fix code according to fuzzer findings - #30286

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-19 09:39:08 +03:00
Shiven Solanki
b115669203 core: use TEST_P for the compare scalar test 2026-10-19 14:16:40 +08:00
Alexander Smorkalov
22d61d85da Merge pull request #30341 from sshivensolanki:fix-findnonzero-fp8
core: fix findNonZero for fp8 depths
2026-10-19 09:09:46 +03:00
Shiven Solanki
e5e48d2287 core: fix OpenCL compare with a scalar for CV_32U, CV_64U and CV_64S 2026-10-19 13:07:34 +08:00
harjoth
92fba91828 core: fix Mat vector constructor docs for 1D matrices
Mat(const std::vector<_Tp>&, bool) in 5.x creates a 1D matrix
(dims == 1, rows == 1, cols == vec.size()), not a single column.
Update the doc to match the implementation and the Mat_ overload wording.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 23:19:01 -07:00
Shiven Solanki
4afcf85e31 core: fix out-of-bounds lookups in ocl::typeToStr tables for 5.x depths 2026-10-18 00:07:50 +08:00
pranayr710
32b8669583 core: stop convertTo() treating CV_64U as signed
CV_64U is the only unsigned depth whose range does not fit in the signed type of the same width, so
reading its bit pattern as signed goes unnoticed until the top bit is set. Three places did.

1. CV_64U -> CV_64S dispatched to cvt64s, a raw byte copy, so nothing saturated: 2^63 became
   INT64_MIN and UINT64_MAX became -1, at every length. CV_32U -> CV_32S saturates, so this is now
   a saturating conversion like the rest.

2. vx_load_pair_as(const uint64_t*, v_float64&, v_float64&) and
   vx_load_as(const uint64_t*, v_float32&) both converted with v_cvt_f64(), which takes signed
   lanes, so CV_64U to CV_64F, CV_32F, CV_16F and CV_16BF returned negative values above INT64_MAX.
   Vector body only, so the same value was right at length 1 and wrong at length 16.

The unsigned conversion splits into two halves below 2^32: each converts exactly, scaling the high
half by 2^32 is exact, and the single add is the only rounding, so the result matches (double)x.
Converting the bit pattern as signed and adding 2^64 back would round twice - for 2^63 + 1025 that
gives 2^63 where (double)x is 2^63 + 2048.

Core_ConvertFrom64U covers the integer and floating-point destinations, with 2^63 + 1025 among the
values since it is the case that distinguishes one rounding from two.
2026-10-17 00:30:36 +05:30
Shiven Solanki
b1a94cda72 core: fix findNonZero for fp8 depths 2026-10-17 00:08:23 +08:00
Prasadayus
6fa897e2ee fix int16 overflow in NEON v_dotprod_expand for int8 2026-10-16 20:16:55 +05:30
Alexander Smorkalov
e01b84826c Merge pull request #30334 from brad0:elf_aux_info_check
core: check elf_aux_info() return value on ppc64
2026-10-16 14:09:45 +03:00
Savya Sanchi Sharma
593b70435d Merge pull request #30259 from SavyaSanchi-Sharma:core/umat
core: explicit UMat transfers for non OpenCL builds - #30259

## Summary

Core groundwork for moving the DNN CUDA backend from mapped `getMat()` to explicit host/device copies (related: #29807): 
-`fitSameSize` keeps tensor layout, the missing `_OutputArray::fit*` overloads are defined, `UMat::create` reports a failing bound allocator, and cross-allocator `copyTo` no longer maps a device destination.
- OpenCL paths (`Kernel::set`, `isCLBuffer`, clFFT, `arithm_op`) now decline CUDA UMats instead of passing a CUDA pointer as `cl_mem`, which segfaulted with NVIDIA OpenCL.
- Adds a private `HostDeviceBuffer` (CUDA → OpenCL → CPU fallback) for the follow-up DNN PR, with tests for all of the above.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-16 14:08:56 +03:00
Zhewen Tan
37040df206 Merge pull request #30249 from tandede/fix/checkrange-float16
Fix checkRange for new 5.x data types  🤖🤖🤖
2026-10-16 14:06:36 +03:00
Brad Smith
4cab908a95 core: check elf_aux_info() return value on ppc64
elf_aux_info() returns non-zero on failure and leaves the output
buffer untouched. The ppc64 CPU feature detection reused one variable
for both AT_HWCAP and AT_HWCAP2, so if the AT_HWCAP2 lookup failed the
AT_HWCAP value was tested against the PPC_FEATURE2_* bits. Use a
separate variable for AT_HWCAP2 and treat a failed lookup as no
features available.
2026-10-16 04:53:23 -04:00
Alexander Smorkalov
5e581286e4 Merge pull request #30329 from sshivensolanki:fix-sum-error-message
core: report the unsupported type in cv::sum error message
2026-10-16 11:32:40 +03:00
Alexander Smorkalov
2085babb89 Merge pull request #30319 from pbkx:fix-gemm64fc-aliasing-5x
core: fix aliased CV_64FC2 GEMM destination
2026-10-16 11:24:36 +03:00
Shiven Solanki
f365611686 core: report the unsupported type in cv::sum error message 2026-10-16 15:21:15 +08:00
Abhishek Gola
77a13ecaac Merge pull request #30306 from vrabaud/thread_speedup
Do not always call getNumThreads() in splitForParallelStat
2026-10-16 12:27:05 +05:30
Alexander Smorkalov
f7e72ae229 Merge pull request #30323 from aswanth-07:fix/quaternion-small-vector-coefficients-5x
core: Port quaternion small-vector limits to 5.x
2026-10-16 09:49:01 +03:00
Alexander Smorkalov
3074f64f08 Merge pull request #30315 from sshivensolanki:fix-fp8-print
core: support fp8 depths when printing Mat
2026-10-16 08:36:56 +03:00
A Aswanth Raj
88a3a3f240 core: Fix small-vector quaternion limits 2026-10-16 08:16:14 +05:30
pbkx
37d2af1745 fix aliased CV_64FC2 GEMM destination 2026-10-15 14:32:22 -07:00
Vincent Rabaud
d67cc52e52 Fix comment 2026-10-15 13:13:44 +02:00
Shiven Solanki
25091848c5 Merge pull request #30266 from sshivensolanki:fix-ocl-kerneltostr-depths
core: fix out-of-bounds funcs[] lookup in ocl::kernelToStr for 5.x depths - #30266

Fixes #30265

### Problem

`ocl::kernelToStr()` picks a formatting function from `funcs[]`, an 8-entry table indexed by depth. On 5.x a kernel of depth `CV_16BF`, `CV_Bool`, `CV_64U`, `CV_64S` or `CV_32U` indexes past the end of the table. The value read there is normally not null, so the following `CV_Assert(func != 0)` does not catch it and the call through `func` crashes.

### Fix

Declare the table as `funcs[CV_DEPTH_MAX]` and make `kernelToStr()` work for the 5.x depths:

- `CV_Bool`, `CV_64U`, `CV_64S` and `CV_32U` get `kerToStr` entries and are printed by its default branch.
- `CV_16BF` and the fp8 depths (`CV_8F_E4M3FN`, `CV_8F_E4M3FNUZ`) have no OpenCL literal form, so the kernel is converted to `CV_32F` and printed as a regular float.

Entries that are not listed stay zero-initialized, so the existing `CV_Assert(func != 0)` still guards any depth added later. Output for `CV_8U` to `CV_16F` is unchanged.

`predictOptimalVectorWidth()` in the same file already sizes its depth-indexed table this way.

### Tests

`OCL_KernelToStr_Depth.new_depths` is parameterized over `CV_16BF`, `CV_Bool`, `CV_64U`, `CV_64S`, `CV_32U`, `CV_8F_E4M3FN` and `CV_8F_E4M3FNUZ`, and checks the string returned by `kernelToStr()`.

On current 5.x (macOS, Apple M1 Pro) the test binary crashes on the first case. With this patch all seven pass, with OpenCL enabled and with `OPENCV_OPENCL_DEVICE=disabled`. The other `OpenCL.*` and `OCL_*` tests in `opencv_test_core` still pass locally.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
2026-10-15 12:50:26 +03:00
pranayr710
ec1ee5a5fb Merge pull request #30199 from pranayr710:fix/convert-32u-signed-and-precision
core: fix convertTo() from CV_32U returning negative values for CV_16BF and losing precision for CV_64F - #30199

Fixes #30198.

Two entries in the `32u` block of `convert.simd.hpp` pick the wrong type. Both make `convertTo()` from `CV_32U` return something an unsigned source cannot produce, and both are one-line changes.

### 1. `CV_32U -> CV_16BF` declared its source as `int`

```cpp
DEF_CVT_FUNC(32u16bf, cvt1_, int, bfloat, v_float32)
```

Every other entry in the block says `unsigned`, including the neighbouring `CV_32U -> CV_16F`, which is correct. So everything above `INT_MAX` was read as negative - `UINT_MAX` converted to `-1`, `3000000000` to `-1291845600`.

This one is wrong at **every length, scalar path included**, because the type is wrong at the declaration rather than in the vector code.

### 2. `CV_32U -> CV_64F` widened through `float`

```cpp
DEF_CVT_FUNC(32u64f, cvt_, unsigned, double, v_float32)
```

`float` has a 24-bit mantissa and cannot hold a `uint32`, so values above 2^24 were rounded on the way to a destination that represents all of them exactly: `16777217` came back as `16777216`, `UINT_MAX` as `4294967296`. Only the vector body was affected, so the same value was correct at length 8 and wrong at length 16.

`CV_32U` was the only integer depth converting to `CV_64F` through `float` - `8U`, `8S`, `16U`, `16S` and `32S` go via `v_int32`, `64U` and `64S` via `v_float64`. It now uses the exact 64-bit path like the rest.

### One thing that needed care

`vx_load_pair_as(const unsigned*, v_float64&, v_float64&)` backed that exact path with a scalar spill through a buffer, so simply switching to it would have traded precision for speed - which is not a trade worth offering. It now widens to 64 bits and uses the existing signed conversion, exact because every `uint32` is a non-negative `int64`, and stays vectorized:

```cpp
v_uint64 lo, hi;
v_expand(vx_load(ptr), lo, hi);
a = v_cvt_f64(v_reinterpret_as_s64(lo));
b = v_cvt_f64(v_reinterpret_as_s64(hi));
```

No new HAL primitive is needed - `v_cvt_f64(v_int64)` exists on every backend.

### How these were found

A length-independence sweep over the element-wise operations: 2688 combinations of depth, boundary value and length, checking that an element's result never depends on how many elements sit beside it.

Worth recording that the sweep's first output was misleading. It reported `add`, `absdiff` and `multiply` on `CV_32U` as broken, because it compared results via `convertTo(CV_64F)` - which is defect 2. Reading the raw `uint32` lanes instead showed all three are exact, and that the readback was the bug. I would have filed three imaginary bugs by trusting the first run.

### Testing

`Core_ConvertFrom32U` asserts that no conversion from `CV_32U` is ever negative, and that `CV_64F` - the only destination here that can represent every `uint32` - is exact. Lengths straddle the vector width so the body, the tail and the two together are covered.

Checked it fails without the patch rather than assuming: **36 of its 224 cases fail** on current 5.x with only the test applied.

With the patch: 228/228 on `*ConvertTo*` and `*ConvertFrom32U*` at both the default dispatch and `OPENCV_CPU_DISABLE=AVX2,AVX,FP16`. Full `opencv_test_core` 17185 passed, with only the 7 filestorage/globbing failures this machine always has.

### Note on overlap

#30178 also touches `convert.hpp` and `test_arithm.cpp`, but in the other direction (16-bit float sources into wide integer destinations) and in different regions of both files, so there is no functional overlap - only a possible textual conflict in the test file, which I am happy to rebase around.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-15 12:38:17 +03:00
Vincent Rabaud
6b464d8613 Do not always call getNumThreads() in splitForParallelStat 2026-10-15 10:37:45 +02:00
Shiven Solanki
9009d5b62b core: support fp8 depths when printing Mat 2026-10-15 14:41:15 +08:00
Shiven Solanki
19fc7d3052 core: support fp8 depths in split, merge and mixChannels 2026-10-14 21:20:21 +08:00
Vincent Rabaud
670368ab56 Add missing ReduceParams wasm bindings 2026-10-14 13:55:26 +02:00
Abhishek Gola
3f426d1f1b Merge pull request #30207 from abhishek-gola:core-drop-nd-suffix
drop ND prefix from the functions - #30207

Merge pull request #30207 from abhishek-gola:core-drop-nd-suffix

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-14 11:26:22 +03:00
Vincent Rabaud
57c4544b70 use float32 intermediate instead of float16 for CV_8U and CV_8S
On ARM with CV_SIMD_16F, getMulFunc_, getDivFunc_, and getAddWeightedFunc_
used float16 for 8-bit integer SIMD kernels, leading to precision loss
and overflow (> 65504). Switch to float32 to match x86 and ensure precision.
2026-10-13 11:35:33 +02:00
Alexander Smorkalov
d654f97d8e Merge pull request #30222 from vrabaud:autobuffer
reduce TExpr::exec stack buffer size from 16 KB to 4 KB
2026-10-13 08:48:34 +03:00
Savya Sanchi Sharma
303f83ef92 Merge pull request #29729 from SavyaSanchi-Sharma:vizsplat
Added Gaussian Splat Renderer Support - #29729

Adds 3D Gaussian Splatting support to `ptcloud`: a loader for trained scenes and a `viz3d` renderer that draws them alpha-blended and depth-sorted alongside existing opaque geometry.

### Result

<img width="1842" height="811" alt="splat" src="https://github.com/user-attachments/assets/abfa5c01-6dbb-4367-b426-a618e3748649" />

[.splat source](https://huggingface.co/cakewalk/splat-data/resolve/main/train.splat)

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-12 16:33:54 +03:00
Alexander Smorkalov
a232314184 Merge pull request #30185 from asmorkalov:as/arithmetics_fix
Fix Scalars and small matrix broadcasting logic. - #30185

Replaces https://github.com/opencv/opencv/pull/30166

**non-continuous** array of the same shape and type (e.g. a column `P.col(0)` of a 4xN matrix of homogeneous 3D
points) silently treats the continuous operand as a `cv::Scalar` and broadcasts its first element:

`cc` continuous 4x1 `CV_64FC1`, `P.col(0)` same shape but non-continuous
cc = [10, 20, 30, 40] — a continuous 4x1 CV_64FC1.
It comes from P, a 4x10 CV_64F matrix filled with `P.at<double>(i,j) = 10*(i+1) + j:`
```
P = [ 10 11 12 ... 19
      20 21 22 ... 29
      30 31 32 ... 39
      40 41 42 ... 49 ]
```

### Same-shape pair

| op | src1 | src2 | Expected | 4.x (4.6) | 5.x HEAD | 5.x + PR 30185 |
|---|---|---|---|---|---|---|
| `subtract` | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`0 -10 -20 -30`** | `0 0 0 0` |
| `subtract` | `P.col(0)` | `cc` | `0 0 0 0` | `0 0 0 0` | **`0 10 20 30`** | `0 0 0 0` |
| `add` | `cc` | `P.col(0)` | `20 40 60 80` | `20 40 60 80` | **`20 30 40 50`** | `20 40 60 80` |
| `multiply` | `cc` | `P.col(0)` | `100 400 900 1600` | `100 400 900 1600` | **`100 200 300 400`** | `100 400 900 1600` |
| `divide` | `cc` | `P.col(0)` | `1 1 1 1` | `1 1 1 1` | **`1 0.5 0.33333 0.25`** | `1 1 1 1` |
| `absdiff` | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`0 10 20 30`** | `0 0 0 0` |
| `min` | `cc` | `P.col(0)` | `10 20 30 40` | `10 20 30 40` | **`10 10 10 10`** | `10 20 30 40` |
| `max` | `cc` | `P.col(0)` | `10 20 30 40` | `10 20 30 40` | `10 20 30 40` | `10 20 30 40` |
| `compare EQ` | `cc` | `P.col(0)` | `255 255 255 255` | `255 255 255 255` | **`255 0 0 0`** | `255 255 255 255` |
| `addWeighted` | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`THROW`** | `0 0 0 0` |
| `bitwise_xor` | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`0 2.2e-308 3.6e-308 7.1e-307`** | `0 0 0 0` |
| `subtract` +mask | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`0 -10 -20 -30`** | `0 0 0 0` |
| `operator-` | `cc` | `P.col(0)` | `0 0 0 0` | `0 0 0 0` | **`0 -10 -20 -30`** | `0 0 0 0` |

### Genuine `Scalar` partner

| op | src1 | src2 | Expected | 4.x (4.6) | 5.x HEAD | 5.x + PR 30185 |
|---|---|---|---|---|---|---|
| `subtract` | `cc` | `Scalar(5)` | `5 15 25 35` | `5 15 25 35` | **`5 20 30 40`** | `5 15 25 35` |
| `subtract` | `Scalar(5)` | `cc` | `-5 -15 -25 -35` | `-5 -15 -25 -35` | **`-5 -20 -30 -40`** | `-5 -15 -25 -35` |
| `subtract` | `cc` | `Scalar(5,6,7,8)` | `5 15 25 35` | `5 15 25 35` | **`5 14 23 32`** | `5 15 25 35` |
| `subtract` | `cc` | `Vec4d(5,6,7,8)` | `5 15 25 35` | `5 15 25 35` | **`5 14 23 32`** | `5 15 25 35` |
| `add` | `cc` | `Scalar(5)` | `15 25 35 45` | `15 25 35 45` | **`15 20 30 40`** | `15 25 35 45` |
| `multiply` | `cc` | `Scalar(2)` | `20 40 60 80` | `20 40 60 80` | **`20 0 0 0`** | `20 40 60 80` |
| `divide` | `cc` | `Scalar(2)` | `5 10 15 20` | `5 10 15 20` | **`5 inf inf inf`** | `5 10 15 20` |
| `max` | `cc` | `Scalar(25)` | `25 25 30 40` | `25 25 30 40` | **`25 20 30 40`** | `25 25 30 40` |
| `compare GT` | `cc` | `Scalar(25)` | `0 0 255 255` | `0 0 255 255` | **`0 255 255 255`** | `0 0 255 255` |
| `operator-` | `cc` | `Scalar(5)` | `5 15 25 35` | `5 15 25 35` | **`5 20 30 40`** | `5 15 25 35` |
| `subtract` | `cc` | `Scalar::all(5)` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` |
| `subtract` | `cc` | `Vec<double,1>(5)` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` |
| `subtract` | `UMat cc` | `Scalar(5)` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` | `5 15 25 35` |

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [ ] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
2026-10-12 13:38:25 +03:00
Abhishek Gola
25beda402a Merge pull request #30157 from abhishek-gola:core-reduce-nd
core: reduceND, used by the DNN Reduce2 layer - #30157

Split out of #30082, which now carries only the resize half.

Adds `cv::reduceND`, which reduces an n-dimensional array over a set of axes with any of the `ReduceTypes`, extended with `REDUCE_PROD`, `REDUCE_L1`, `REDUCE_L2`, `REDUCE_LOG_SUM` and `REDUCE_LOG_SUM_EXP`. `cv::reduce` accepts n-dimensional input through it.

`sum`, `mean` and `minMaxIdx` now share one parallel driver (`stat_parallel.hpp`), so they parallelize over large arrays the same way `reduceND` does.

The new graph engine's `Reduce2` layer calls `cv::reduceND` instead of its own kernels, so `reduce2_kernels.simd.hpp` and the hand-written reduction loops in `reduce2_layer.cpp` go away.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
2026-10-12 12:08:20 +03:00
Abhishek Gola
0054f3aa7e Merge pull request #30159 from pranayr710/fix/norm-l1-32s
core: fix cv::norm(CV_32S, NORM_L1) returning negative at INT_MIN and losing precision above 2^24
2026-10-12 13:27:56 +05:30
Alexander Smorkalov
31d0b67649 Merge pull request #30232 from vrabaud:pop_back
core: decrement size directly in AutoBuffer::pop_back()
2026-10-12 09:27:13 +03:00
Vincent Rabaud
282e14732f allow empty array with scalar operand in arithm_op
Previously, arithm_op returned an empty output when one operand was an
empty Mat and the other was a Scalar.
The new element-wise engine asserted `src1.empty() == src2.empty()` before
checking `isScalarArg`, causing calls such as `cv::max(empty_mat, 1.0, dst)`
or `cv::add(empty_mat, Scalar(1), dst)` to fail with an assertion error.
2026-10-11 22:13:22 +02:00
Vincent Rabaud
30a7014ecc core: decrement size directly in AutoBuffer::pop_back()
Calling resize(size() - 1) in pop_back() pulls in the buffer growth path
for the unreachable sz == 0 case in release builds (where size() - 1
underflows to SIZE_MAX), which both bloats codegen and triggers an LLVM
ScalarEvolution assertion on 32-bit Hexagon Clang. Guard and decrement
sz directly instead.
2026-10-11 10:36:48 +02:00