Commit Graph

6253 Commits

Author SHA1 Message Date
Shiven Solanki
a20d208db5 doc(core): note unsupported input depths in inRange and addWeighted
inRange rejects CV_Bool and CV_8F inputs and addWeighted rejects CV_Bool inputs, but the docs did not say so. Also fix type-name typos in core.hpp (CV8S, CV_8S1) and two other spelling mistakes.
2026-11-12 07:55:35 +08:00
Shiven Solanki
2404ce75c1 core: add insertChannel and extractChannel test for all depths (#30625)
* core: add insertChannel and extractChannel test for all depths

insertChannel had no CPU test that checks its values, and extractChannel
was only checked on CV_8UC3. Add a test for every depth with 2 to 4
channels: inserting into one channel must leave the others unchanged,
and extractChannel must return the inserted channel.

* core: use CV_DEPTH_CURR_MAX in insertChannel test

Cover every depth with a range instead of listing them by hand, so new
depths are tested automatically.
2026-11-11 14:45:51 +05:30
Abhishek Gola
f6211c548e Merge pull request #30746 from Prasadayus/optimize/ppl-arm64-rebalance
core: replace ARM64 PPL's static partitioning with adaptive self-scheduling
2026-11-11 10:24:16 +05:30
Prasadayus
fc776d14a2 core: replace ARM64 PPL's static partitioning with adaptive self-scheduling 2026-11-10 18:25:23 +05:30
Abhishek Gola
370175b3bd Merge pull request #30624 from sshivensolanki/core-lut-test-bool
core: remove CV_Bool conversion from LUT tests
2026-11-10 16:23:21 +05:30
Shiven Solanki
f5f76c0786 core: fix cv_absdiff overflow for int64 in norm of CV_64S
Fixes #30731
2026-11-10 00:32:38 +08:00
Andrei Fedorov
2e0c9a44e6 Merge pull request #30663 from intel-staging:andreyfe1/5.x/extend_perf_tests
Porting of perf tests extension from 4.x to 5.x - #30663

Following PRs are being ported:
* #29908
* #29922 
* #29972

No more changes are introduced.
PR for opencv-extra: https://github.com/opencv/opencv_extra/pull/1458

### 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
- [ ] 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-11-09 11:46:44 +03:00
Shiven Solanki
566df44633 core: support fp8 depths in cv::sum and cv::mean (#30670)
* core: support fp8 depths in cv::sum

cv::sum and cv::trace threw for CV_8F_E4M3FN and CV_8F_E4M3FNUZ. Add
sum8f and sum8fnuz to the function table, and collect their float totals
in blocks like CV_16F and CV_16BF.

* core: test cv::sum on fp8 past the block size

Add a (1 << 15) + 1 element case to Core_Sum_FP8, so the float total is
moved to the double result and reset between blocks.

* core: support fp8 depths in cv::mean

cv::mean uses the same adding functions as cv::sum, so adding fp8 to that table made it accept these depths. Its blockSum check still left them out, so the float totals were written straight into the double result and the mean came back wrong. Use the block path for CV_8F_E4M3FN and CV_8F_E4M3FNUZ, as cv::sum does, and check cv::mean in Core_Sum_FP8.

* core: test cv::mean with a mask on fp8

* core: split Core_Sum_FP8 into sum, mean and mean_mask tests

Move the array setup into a fixture, and make the length a test parameter, so each case runs on its own.
2026-11-09 09:41:13 +05:30
Shiven Solanki
bb8cbcdb0b Merge pull request #30715 from sshivensolanki:core-carttopolar-inplace-5x
core: fix in-place cartToPolar when only the magnitude overwrites an input (5.x) - #30715

5.x port of #30646, as requested in its review. Fixes #30645 on 5.x.

### Problem

`cv::cartToPolar` gives wrong results on `CV_32F` when only the magnitude output is the same `Mat` as `x` or `y`. The SIMD tail handling repeats the last full block, and `cartToPolar32f_` only skipped that for in-place calls when the angle was aliased.

### Fix

Same as #30646: added `mag == X || mag == Y` to the check, so these calls handle the leftover elements with the scalar code.

### Tests

Same `Core_CartToPolar_inplace_mag.accuracy` test as #30646 (`CV_32F`, lengths 1 to 39, magnitude overwriting `x`, then `y`). On Apple M1 Pro it fails without the fix on 5.x and passes with it. The full `opencv_test_core` passes.

### 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-11-08 11:47:11 +03:00
pranayr710
1780d20b80 core: vectorize cv::sum for CV_64F (#30582)
* core: vectorize cv::sum for CV_64F

Sum_SIMD has specializations for the 8-, 16- and 32-bit depths, but not for
CV_64F, so cv::sum and cv::mean on a double matrix fall through to the scalar
unrolled loop in sum_. CV_64FC1 is not in TYPICAL_MAT_TYPES, so no perf test
covered it.

The source type is already the accumulator type, so the specialization needs
neither expansion nor conversion: it loads three vectors at the native width and
adds them. The channel limit matches DEFINE_SUM_SIMD_32 because init_maskbuf can
only build the cn == 4 masks once the vector holds four lanes, which rules the
case out on an SSE2 baseline.

Extend sum_wide with the CV_64F rows so the change is measurable.

* core: reuse DEFINE_SUM_SIMD_16 for CV_64F

Drop the near-duplicate DEFINE_SUM_SIMD_64 and instantiate DEFINE_SUM_SIMD_16
with v_float64 instead, as suggested in review.

The one thing that kept the two apart was the channel guard. DEFINE_SUM_SIMD_16
rejects cn > 4, which is correct only while the vector holds at least four lanes:
init_maskbuf builds the cn == 4 masks under that condition, so with a narrower
vector the reduction runs against all-zero masks and drops the vectorized
elements without reporting anything. Every 32-bit register type has four lanes or
more, so the existing instantiations never saw it; v_float64 has two on an SSE2
baseline.

Widening the guard to the DEFINE_SUM_SIMD_32 form leaves the existing
instantiations unchanged, since 3+(simd_width>=4) is 4 for all of them.
2026-11-08 08:31:23 +05:30
Kumataro
e027ae3f3b core, videoio: fix C++20 compilation warnings for enum-to-double conversions
- Replace anonymous enums with `constexpr` variables.
- Add `static_cast<double>()` to enum values in `EXPECT_EQ` assertions.
2026-11-07 20:13:55 +09:00
Alexander Smorkalov
07666386e2 Merge branch 'release_5.1.0' into 5.x 2026-11-05 16:14:14 +03:00
Alexander Smorkalov
e4f78fbcf1 release: OpenCV 5.1.0 2026-11-05 14:18:05 +03:00
Shiven Solanki
545147fdab Merge pull request #30685 from sshivensolanki:core-filestorage-unsigned
core: keep large CV_32U values when reading with FileStorage - #30685

Fixes #30684

### Problem

When a `CV_32U` `Mat` was loaded with `FileStorage`, values above `INT_MAX` came back as `0`, in YAML, XML and JSON, with and without base64. The saved file had the correct values, so only reading was affected.

### Fix

- `FileNodeIterator::readRaw` read elements of up to 4 bytes through `(int)node`, so these values turned negative and the `CV_32U` case clamped them to 0. It now always reads the node as `int64_t`. Each case still converts the value to its own type.
- The base64 path stored `getInt32()` as signed, so `CV_32U` now uses a new `Base64Decoder::getUInt32()`, like `getUInt8()` and `getUInt16()`.

`CV_64U` values above `INT64_MAX` are also lost in the text formats, but that has a different cause, in the parsers' `strtoll`, so it is not part of this PR.

### Tests

New `Core_InputOutput.filestorage_32u_large_values` saves values on both sides of `INT_MAX` and loads them back, in YAML, XML and JSON, with and without base64. All 6 combinations fail without the fix, and the test passes with it on Apple M1 Pro.

### 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-11-05 14:17:21 +03:00
tanveer-arch
1727c38423 Merge pull request #30072 from tanveer-arch:investigate-30067-tbb-lifetime
core: avoid TBB static destruction during Windows teardown - #30072

## Summary

Avoid destruction of the TBB task arena/scheduler during C++ static teardown.

On Windows with the UCRT and TBB backend, process teardown can involve
interaction between TBB cleanup and the Windows loader/CRT shutdown path.
Keeping the OpenCV-owned TBB arena/scheduler alive until process termination
avoids invoking its destructor during static destruction.

## Validation

- Reproduced the reported teardown deadlock with the MSYS2 packaged
  OpenCV 5.0.0 environment.
- Built OpenCV 5.x locally with TBB enabled.
- The patched local build completed 2,001 stress-test iterations without
  reproducing the deadlock.
- `git diff --check` passes.

The local 5.x baseline did not reproduce the issue during the available
baseline stress run, so the stress result is considered supporting evidence
rather than a definitive reproduction/fix confirmation.

Related issue: #30067
2026-11-05 10:26:42 +03:00
Vincent Rabaud
5bbf4b4b93 fix NaN inequality semantics in v_ne for AVX, AVX-512, LSX, and LASX
Ordered not-equal predicates (_CMP_NEQ_OQ in AVX/AVX-512 and
vfcmp_cne/xvfcmp_cne in LoongArch LSX/LASX) return false when either
operand is NaN, violating IEEE-754 != semantics and diverging from C++,
SSE (_mm_cmpneq_ps/_pd), NEON, MSA, VSX, WASM, and RVV implementations
(as well as callers like intrin_math.hpp that use v_ne(x, x) to detect
NaNs).

Switch floating-point v_ne to unordered not-equal (_CMP_NEQ_UQ and
vfcmp_cune/xvfcmp_cune) and add NaN coverage to test_cmp().
2026-11-04 10:17:08 +01:00
Abhishek Gola
2da0a498da outline 4KB temp scratch buffers in TExpr::exec (#30660)
Even after 0e20693a8d reduced the inline temp scratch buffers from 16KB
to 4KB, Clang hoists the fast-strip `scratchBuf` (~4.3KB) into
`TExpr::exec()`'s prologue when taking the `broadcastOp` path, while the
`broadcastOp` lambda unconditionally reserves another ~4.3KB `tstoreBuf`
on the stack even when `nbuffers == 0`. Together with `arithm_op()` and
`BroadcastOp::run()`, a single `cv::subtract` or `cv::compare` consumes
nearly 19KB of stack space on the calling thread, overflowing 64KB
fiber/coroutine stacks under deep call chains (e.g. `calibrateCameraRO`).

Outline the temp-bearing loops into `noinline` helpers
(`execFastStripWithTemps` and `execTileWithTemps`) and run the
`nbuffers == 0` tile body directly without `tstoreBuf`. This preserves
4KB L1 fragments when temporaries are present while saving ~8.7KB of
stack space on single-op `broadcastOp` calls.
2026-11-04 14:18:06 +05:30
Vincent Rabaud
e40204af2b Have EwMul::scl match the SIMD implementation in vecBinaryKernel (#30643)
* match SIMD and scalar scale association in EwMul

Restore `EwMul::scl` from `(a * b) * s` to `(a * s) * b` so the scalar
path matches SIMD `vec(preproc(a, s), b)` and avoids premature `float`
overflow on `a * b`.

Canonicalize single-sided `src1` broadcasts (`s1x == 0` or `s1y == 0`)
onto `src0` for `EwMul` in `vecBinaryKernel` and `scalarBinaryKernel`,
preserving loop-hoisted `b * s` in SIMD while matching the `(b * s) * a`
grouping in the scalar tails.

* Add more tests
2026-11-04 12:52:29 +05:30
Vincent Rabaud
d4a4497e38 outline 4KB temp scratch buffers in TExpr::exec
Even after 0e20693a8d reduced the inline temp scratch buffers from 16KB
to 4KB, Clang hoists the fast-strip `scratchBuf` (~4.3KB) into
`TExpr::exec()`'s prologue when taking the `broadcastOp` path, while the
`broadcastOp` lambda unconditionally reserves another ~4.3KB `tstoreBuf`
on the stack even when `nbuffers == 0`. Together with `arithm_op()` and
`BroadcastOp::run()`, a single `cv::subtract` or `cv::compare` consumes
nearly 19KB of stack space on the calling thread, overflowing 64KB
fiber/coroutine stacks under deep call chains (e.g. `calibrateCameraRO`).

Outline the temp-bearing loops into `noinline` helpers
(`execFastStripWithTemps` and `execTileWithTemps`) and run the
`nbuffers == 0` tile body directly without `tstoreBuf`. This preserves
4KB L1 fragments when temporaries are present while saving ~8.7KB of
stack space on single-op `broadcastOp` calls.
2026-11-03 16:17:42 +01:00
kevin9327
6cae2e3701 core: read numbers with an upper-case exponent in FileStorage 2026-11-03 16:24:39 +03:00
Abhishek Gola
f5fab22f7c Merge pull request #30626 from Prasadayus/optimize/imgproc-arm64-perf
imgproc: recover calcHist ARM64 perf regressions
2026-11-03 13:07:06 +05:30
Abhishek Gola
3fdade4e9c Merge pull request #30634 from Prasadayus/optimize/core-norm-arm64-perf
core: recover norm(NORM_L1, CV_32S) perf lost to its correctness fix
2026-11-03 13:05:31 +05:30
Alexander Smorkalov
845bae8b7d Tolerance tuning for FastCV HAL. 2026-11-02 21:49:16 +03:00
Prasadayus
ffb4fb40f8 drop bilateralFilter early-exit restoration, no regression found 2026-11-02 18:57:13 +05:30
Prasadayus
24b3a82376 address review feedback on calcHist/bilateralFilter fixes 2026-11-02 16:35:12 +05:30
Abhishek Gola
739c1e60fd Merge pull request #30611 from sshivensolanki/fix-bitwise-not-bool
core: make bitwise_not a logical NOT for CV_Bool
2026-11-02 14:48:40 +05:30
Prasadayus
af40ab48ca core: recover norm(NORM_L1, CV_32S) perf lost to its correctness fix 2026-11-02 13:27:17 +05:30
Shiven Solanki
482f8f784b core: remove CV_Bool conversion from LUT tests
The Core_LUT tests converted CV_Bool results to CV_8U before comparing
them, because cv::norm did not support CV_Bool at the time. cv::norm
handles CV_Bool now, so remove the conversion and its TODO.
2026-11-02 13:09:19 +08:00
Shiven Solanki
45080272b8 core: support CV_16F and CV_16BF in patchNaNs
patchNaNs asserted CV_32F or CV_64F input, so 16-bit float arrays,
which can hold NaN too, could not be patched.

Add patchNaNs_16, the same bit test as the 32-bit kernel on 16-bit
words, with the infinity pattern of each format (0x7c00 for CV_16F,
0x7f80 for CV_16BF). getPatchNanFunc now takes the depth. The OpenCL
kernel only handles float and double, so other depths fall back to
the CPU path.
2026-11-01 04:47:29 +08:00
Abhishek Gola
c4f7634256 Merge pull request #30183 from abhishek-gola/python-ml-dtypes
python: keep exact bfloat16 / float8 dtypes in the bindings via ml_dtypes
2026-10-31 20:26:08 +05:30
Shiven Solanki
806a40d66e core: treat any non-zero CV_Bool as true in bitwise_not, skip OpenCL
- The CV_Bool NOT kernel now computes x == 0 instead of x ^ 1, so a
  non-0/1 byte (still true, as in convertTo) becomes 0 instead of 254.
  The cvtest::logicOp reference does the same.
- bitwise_not no longer tries OpenCL for CV_Bool. It already ended up
  on the CPU kernel, but only because memopTypeToStr() asserts on
  CV_Bool and CV_OCL_RUN catches the exception.
- Core_Bitwise.not_bool also checks a UMat input and 255 bytes in both
  the SIMD loop and the scalar tail.
2026-10-31 22:22:25 +08:00
Shiven Solanki
693cc84722 core: make bitwise_not a logical NOT for CV_Bool
The NOT kernel was picked by element size only, so CV_Bool ran the
same ~x kernel as CV_8U and turned 0/1 into 255/254. Both are non-zero,
so every element of ~mask counted as true. Pass the depth to
getNotFunc and use x ^ 1 for CV_Bool. Fix the same ~x in the
cvtest::logicOp reference, which made Core_Not expect 254.

Add a Core_Bitwise regression test.
2026-10-31 18:09:59 +08:00
Abhishek Gola
8ce9c2c1be Merge pull request #30579 from sshivensolanki/fix-norm-fp8
core: support fp8 depths in cv::norm
2026-10-31 12:58:21 +05:30
Alexander Smorkalov
d73763f09c Merge pull request #30570 from pranayr710:fix/reduce-depth-coverage
core: support CV_8S and CV_32S in cv::reduce
2026-10-30 14:36:38 +03:00
Abhishek Gola
8751eb491e python: drop the CV_16BF -> float32 mapping, share the empty / 0-D output path, run flag tests without ml_dtypes
Signed-off-by: Abhishek Gola <abhishek.gola@bigvisionllc.com>
2026-10-30 15:59:00 +05:30
Abhishek Gola
576defd806 Merge pull request #30466 from tushar152006/fix-convert-fp-to-64int-range
core: fix convertTo() losing values above int32 when converting from FP to 64-bit int
2026-10-30 14:12:03 +05:30
Shiven Solanki
d107ce0e5c core: compare fp8 norm test with EXPECT_DOUBLE_EQ
With IPP, cv::norm of the CV_32F reference computes NORM_L2SQR as the square of NORM_L2, which can be off by 1 ulp (66.5625 vs 66.56250000000001).
2026-10-30 16:02:39 +08:00
utibenkei
9d40b84107 Merge pull request #29851 from utibenkei:fix-java-mat-get-put
java: fix Mat get/put JNI for 0D/1D/ND Mats in OpenCV 5 - #29851#29851

## Summary

Fix incorrect behavior of Java `Mat.get()` / `Mat.put()` JNI bindings for
0D (scalar), 1D, and ND `cv::Mat` objects.
The Java JNI layer in `modules/java/generator/src/cpp/Mat.cpp` still assumed
essentially 2D row/col indexing in several get/put code paths. This caused
wrong results or failed access for scalar and 1D Mats, and incorrect bounds
handling for ND Mats accessed via index arrays.
This PR updates the native get/put helpers in `Mat.cpp` and adds regression
tests in `modules/core/misc/java/test/MatTest.java`.

## Problem (before this patch)
### 1. 0D (scalar) Mats
- `Mat::ptr(const int*)` requires `dims >= 1`, so idx-based paths that called
  `m->ptr(idx.data())` directly (e.g. `nGetIdx`, `mat_copy_data`, `PUT_ITEM_IDX`)
  could not access a true 0D Mat correctly.
- `idx2Offset()` always read `indices[0]` without checking `dims <= 0`.
- Row/col helpers always built a 2-element index `{row, col}` instead of an
  empty index vector for 0D Mats.
Although OpenCV 5 supports 0D Mats at the C++ level, the Java wrapper did not
correctly implement idx-based access with an empty index array (`new int[]{}`).
This PR adds explicit JNI support for that case via `mat_elem_ptr()` and
related helpers.
**Example:** For `Mat m = new Mat(new int[]{}, CvType.CV_64F)` (`dims()==0`),
`m.put(new int[]{}, 42.0)` and `m.get(new int[]{}, buf)` could fail or access
the wrong memory.
### 2. 1D Mats (`dims() == 1`)
- Row/col get/put always converted `(row, col)` to `{row, col}` (length 2),
  while a 1D Mat requires a single-element index vector.
- For a 1D Mat, OpenCV 5 represents the shape as `dims == rows == 1` and
  `cols == total() == N`. The Java row/col access path must therefore interpret
  `(row, col)` as the 1D element index represented by `col` (with `row == 0`),
  converting internally to `{col}` via `row_col_to_idx()`.
**Example:** For `Mat m = new Mat(new int[]{10}, CvType.CV_32F)`, calling
`m.put(0, 3, values)` could behave incorrectly because native code treated
the access as `{0, 3}` instead of `{3}`.
### 3. ND Mats (`dims() > 2`) via row/col API
- Row/col get/put only checked `rows` and `cols`, without rejecting Mats with
  `dims > 2`.
- ND Mats must be accessed via idx-based APIs; using row/col on them could
  produce silently wrong results instead of failing early.
### 4. Idx-based API bounds checking
- Old code checked `size[i] <= idx[i]` but did not validate:
  - `idx.length == dims`
  - negative index values
- `nPutDIdx` computed the number of remaining elements with a per-dimension
  product loop (`channels * (size[i] - idx[i]) * ...`). For ND Mats, this did
  not correctly account for the current linear index position when determining
  how many elements remain from the selected subarray onward. The fix uses
  `(total() - idx2Offset(m, idx)) * channels()`, which matches the linear
  layout used by `mat_copy_data()`.

## Changes
- Add `mat_elem_ptr()` to support 0D scalar Mats (`Mat::ptr(const int*)`
  requires `dims >= 1`).
- Add `check_row_col_access()`, `check_idx_access()`, and `row_col_to_idx()`
  to validate access and convert row/col indices according to OpenCV semantics.
- Update `idx2Offset()`, `offset2Idx()`, and `mat_copy_data()` for 0D/1D Mats.
- Route row/col get/put through `row_col_to_idx()` (1D: element index in `col`,
  `row == 0`).
- Restrict row/col APIs to Mats with `dims <= 2`; ND Mats must use idx-based
  APIs (`nGet*Idx`, `nPut*Idx`, `nGetIdx`, `nPutDIdx`).
- Fix remaining-element calculation in `nPutDIdx` to use `idx2Offset()`.

## Behavior notes
| API | 0D Mat (`dims==0`) | 1D Mat (`dims==1`) | 2D Mat | ND Mat (`dims>2`) |
|-----|-------------------|-------------------|--------|-------------------|
| `get/put(int[] idx, ...)` | supported (`idx.length == 0`; added by this PR) | supported (`idx.length == 1`) | supported | supported |
| `get/put(row, col, ...)` | supported (`row=0`, `col=0`) | supported (index in `col`, `row=0`) | supported | rejected at JNI layer return 0; |
| `get(row, col)` | supported | supported | supported | rejected at JNI layer return 0; |
| `get(int[] idx)` | supported | supported | supported | supported |

## Test plan
Added regression tests in `MatTest.java`:
- `testGetPut0DMat` — idx and row/col get/put on a scalar Mat (`new int[]{}`)
- `testGetPut1DMat` — idx and row/col get/put on `new Mat(new int[]{5}, ...)`
- `testGetPut1DMatDoubleArray` — bulk double put/get via idx on a 1D Mat
- `testGetPut3DMat` — row/col API rejected for 3D Mat; idx API works

### 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-30 10:45:13 +03:00
Kumataro
75c70dfc46 Merge pull request #30598 from Kumataro:doc/update_intro_for_v5_1_0
core(doc): update introduction for OpenCV 5.1 - #30598

- Remove redundant highgui and videoio modules.
- Add geometry and ptcloud modules.
- Document new 8-bit floating-point types (CV_8F_E4M3FN and CV_8F_E4M3FNUZ).

### 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
- [ ] 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-30 10:10:54 +03:00
Alexander Smorkalov
f90784c7a3 Merge pull request #30567 from pratham-mcw:windows-arm64-clangcl
Enable clang-cl build on Windows ARM64 with KleidiCV HAL
2026-10-30 09:12:40 +03:00
Abhishek Gola
8143864783 Merge pull request #30539 from sshivensolanki/fix-checkrange-fp8
core: support fp8 depths in checkRange
2026-10-29 18:05:20 +05:30
Abhishek Gola
5fc1aaf807 Merge pull request #30537 from sshivensolanki/fix-reduce-arg-new-depths
core: support CV_Bool and fp8 depths in reduceArgMax and reduceArgMin
2026-10-29 18:03:13 +05:30
Shiven Solanki
e3181e617e core: rename is_fp16 to is_small_float in cv::norm 2026-10-29 16:37:25 +08:00
Shiven Solanki
c415e4fcef Merge pull request #30526 from sshivensolanki:fix-minmax-fp8
core: support fp8 depths in minMaxLoc and minMaxIdx - #30526

Fixes #30525

### Problem

`minMaxIdxTab` (`modules/core/src/minmax.simd.hpp`) has no entries for `CV_8F_E4M3FN` and `CV_8F_E4M3FNUZ`, so `cv::minMaxLoc` and `cv::minMaxIdx` fail with `func != 0` for fp8 input.

### Fix

- `modules/core/include/opencv2/core/private.hpp`: new `CV_TOGGLE_FP8(x)`, the 8-bit version of `CV_TOGGLE_FLT`: it flips the 7 magnitude bits of negative values, so sign-magnitude fp8 bytes compare in the same order as `int8`.
- `modules/core/src/minmax.simd.hpp`: new `minMaxIdx8f`, used for both fp8 depths. It toggles the input in blocks of 1024 bytes and runs the vectorized `minMaxIdx8s` kernel on them.
- `modules/core/src/minmax.dispatch.cpp`: the fp8 result is toggled back and decoded with `fp8_t::decodeLUT()` / `fp8a_t::decodeLUT()`.
- `modules/core/include/opencv2/core.hpp`: removed the outdated `@note` saying that `CV_16F`/`CV_16BF`/`CV_Bool`/`CV_64U`/`CV_64S`/`CV_32U` are not supported for `minMaxLoc` / `minMaxIdx`.

On 1920x1080 input (single thread, Apple M1 Pro), `minMaxLoc` takes 0.14 ms for both fp8 depths (0.11 ms for `CV_8U`), compared with 2.8 ms for the first version of this PR, which converted every element to `float`. NaN values are not handled specially: like any other byte, they are ordered by their toggled bit pattern.

### Tests

`MinMaxSupportedMatDepth` and `MinMaxAccuracyNewTypes` (`accuracy` and `accuracy_with_mask`) now also run on both fp8 depths, including each format's largest value (448 / 240) and masked-out outliers. The 8 new cases fail on current 5.x (`func != 0`) and pass with this patch. I also compared the results with a float reference on 1600 random fp8 inputs of different sizes, with and without a mask: values and locations match.

All `*MinMax*` / `*minMax*` tests in `opencv_test_core` pass locally on Apple M1 Pro (3113 tests), with OpenCL enabled and with `OPENCV_OPENCL_DEVICE=disabled`. The full `opencv_test_core` passes, except 7 tests that need `opencv_extra` test data, which I didn't have locally (FileStorage base64 and globbing).

### 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-29 08:35:30 +03:00
Shiven Solanki
684f8c445e core: support fp8 depths in cv::norm
getNormFunc and getNormDiffFunc had no entries for CV_8F_E4M3FN and
CV_8F_E4M3FNUZ, so cv::norm failed with "func != 0". Add the fp8 kernels
with float accumulators and the same block accumulation as CV_16F and
CV_16BF. Add cv_absdiff overloads for fp8_t and fp8a_t that return
float, so the difference of two fp8 values is not rounded back to fp8.

Add a Core_Norm_FP8 test.
2026-10-29 12:20:06 +08:00
Shiven Solanki
73b5a78e6a core: compare toggled fp8 bytes in checkRange
Address review: like the CV_32F and CV_64F paths, compare integer keys
instead of decoding each fp8 value. CV_TOGGLE_FP8 maps the sign-magnitude
bytes to int8 keys in the same order; the key range [ia, ib) of
[minVal, maxVal) is found once from the decode table, so bounds that are
not fp8 values are still exact. NaN's key is checked separately, since
the E4M3FNUZ NaN sits between the negative values and zero.

Add a Core_CheckRange_FP8 test that checks all 256 values of both fp8
depths against minVal <= v < maxVal for several ranges.
2026-10-29 11:31:06 +08:00
Shiven Solanki
18520b5674 core: compare toggled fp8 bytes in reduceArgMax and reduceArgMin
Address review: instead of decoding each fp8 value to float, compare
the bytes as int8 after CV_TOGGLE_FP8, which keeps the order of the
sign-magnitude values. reduceMinMaxImpl runs on a one-byte ToggledFp8
type, so no temporary copy is needed.

Add -1 to the ReduceArgNewTypes values, so the test fails if the fp8
bytes are compared without toggling.
2026-10-29 11:09:32 +08:00
Alexander Smorkalov
e52dcc2516 Merge pull request #30534 from sshivensolanki:fix-lut-fp8
core: support fp8 lookup tables in LUT
2026-10-28 21:36:30 +03:00
pranayr710
a83d9971b0 core: support CV_8S and CV_32S in cv::reduce
The reduceR_/reduceC_ dispatch is a chain of explicit sdepth/ddepth pairs and has
never carried a CV_8S or CV_32S source row, so cv::reduce rejected both for every
operation and both dim values. 4.x has the same gap.

CV_8S mirrors CV_8U and accumulates in int. CV_32S accumulates in double: OpAdd<int>
evaluates a + b as int before saturate_cast can clamp it, so an int accumulator
overflows. CV_32S -> CV_32S sums are left unsupported for that reason.

Extend Core_ReduceTest to the new combinations, and add cases for the 32-bit
overflow range and the signed 8-bit extremes, which its randu(0, 100) fill cannot
reach. Its support list also omitted 16U/16S REDUCE_MAX/REDUCE_MIN, which the
existing kernels already handle.

Partially addresses #30569.
2026-10-28 18:22:23 +05:30
Pratham Kumar
01499d5150 cmake: enable clang-cl build on Windows ARM64 with KleidiCV 2026-10-28 13:59:54 +05:30