From 1387ac9fae0b8ebbf4db23ec363b19cf6d68e570 Mon Sep 17 00:00:00 2001 From: ffccites <99155080+PDGGK@users.noreply.github.com> Date: Sat, 7 Feb 2026 17:02:41 +0800 Subject: [PATCH 01/32] docs: fix parameter name inconsistency in erode/dilate/morphologyEx documentation - Change 'element' to 'kernel' in LaTeX formulas to match actual parameter name - Fix erode() and dilate() function documentation (lines 2330, 2338, 2362, 2370) - Fix MorphTypes enum documentation (MORPH_OPEN, MORPH_CLOSE, MORPH_GRADIENT, MORPH_TOPHAT, MORPH_BLACKHAT) - Fix backtick formatting in dilate() documentation Resolves #18095 --- modules/imgproc/include/opencv2/imgproc.hpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp index 08571c4547..ccaa78e31c 100644 --- a/modules/imgproc/include/opencv2/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc.hpp @@ -217,15 +217,15 @@ enum MorphTypes{ MORPH_ERODE = 0, //!< see #erode MORPH_DILATE = 1, //!< see #dilate MORPH_OPEN = 2, //!< an opening operation - //!< \f[\texttt{dst} = \mathrm{open} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \mathrm{erode} ( \texttt{src} , \texttt{element} ))\f] + //!< \f[\texttt{dst} = \mathrm{open} ( \texttt{src} , \texttt{kernel} )= \mathrm{dilate} ( \mathrm{erode} ( \texttt{src} , \texttt{kernel} ))\f] MORPH_CLOSE = 3, //!< a closing operation - //!< \f[\texttt{dst} = \mathrm{close} ( \texttt{src} , \texttt{element} )= \mathrm{erode} ( \mathrm{dilate} ( \texttt{src} , \texttt{element} ))\f] + //!< \f[\texttt{dst} = \mathrm{close} ( \texttt{src} , \texttt{kernel} )= \mathrm{erode} ( \mathrm{dilate} ( \texttt{src} , \texttt{kernel} ))\f] MORPH_GRADIENT = 4, //!< a morphological gradient - //!< \f[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src} , \texttt{element} )= \mathrm{dilate} ( \texttt{src} , \texttt{element} )- \mathrm{erode} ( \texttt{src} , \texttt{element} )\f] + //!< \f[\texttt{dst} = \mathrm{morph\_grad} ( \texttt{src} , \texttt{kernel} )= \mathrm{dilate} ( \texttt{src} , \texttt{kernel} )- \mathrm{erode} ( \texttt{src} , \texttt{kernel} )\f] MORPH_TOPHAT = 5, //!< "top hat" - //!< \f[\texttt{dst} = \mathrm{tophat} ( \texttt{src} , \texttt{element} )= \texttt{src} - \mathrm{open} ( \texttt{src} , \texttt{element} )\f] + //!< \f[\texttt{dst} = \mathrm{tophat} ( \texttt{src} , \texttt{kernel} )= \texttt{src} - \mathrm{open} ( \texttt{src} , \texttt{kernel} )\f] MORPH_BLACKHAT = 6, //!< "black hat" - //!< \f[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} , \texttt{element} )= \mathrm{close} ( \texttt{src} , \texttt{element} )- \texttt{src}\f] + //!< \f[\texttt{dst} = \mathrm{blackhat} ( \texttt{src} , \texttt{kernel} )= \mathrm{close} ( \texttt{src} , \texttt{kernel} )- \texttt{src}\f] MORPH_HITMISS = 7 //!< "hit or miss" //!< .- Only supported for CV_8UC1 binary images. A tutorial can be found in the documentation }; @@ -2327,7 +2327,7 @@ Check @ref tutorial_opening_closing_hats "the corresponding tutorial" for more d The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken: -\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] +\f[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{kernel} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] The function supports the in-place mode. Erosion can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently. @@ -2335,7 +2335,7 @@ case of multi-channel images, each channel is processed independently. @param src input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F. @param dst output image of the same size and type as src. -@param kernel structuring element used for erosion; if `element=Mat()`, a `3 x 3` rectangular +@param kernel structuring element used for erosion; if `kernel=Mat()`, a `3 x 3` rectangular structuring element is used. Kernel can be created using #getStructuringElement. @param anchor position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center. @@ -2359,7 +2359,7 @@ Check @ref tutorial_erosion_dilatation "the corresponding tutorial" for more det The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken: -\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] +\f[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{kernel} (x',y') \ne0 } \texttt{src} (x+x',y+y')\f] The function supports the in-place mode. Dilation can be applied several ( iterations ) times. In case of multi-channel images, each channel is processed independently. @@ -2367,7 +2367,7 @@ case of multi-channel images, each channel is processed independently. @param src input image; the number of channels can be arbitrary, but the depth should be one of CV_8U, CV_16U, CV_16S, CV_32F or CV_64F. @param dst output image of the same size and type as src. -@param kernel structuring element used for dilation; if element=Mat(), a 3 x 3 rectangular +@param kernel structuring element used for dilation; if `kernel=Mat()`, a `3 x 3` rectangular structuring element is used. Kernel can be created using #getStructuringElement @param anchor position of the anchor within the element; default value (-1, -1) means that the anchor is at the element center. From dcdd17dbe1f08b87f07d428dd999ab33b1aa2e18 Mon Sep 17 00:00:00 2001 From: Jake Floch <72522226+JakeFloch@users.noreply.github.com> Date: Thu, 12 Feb 2026 05:51:57 +0000 Subject: [PATCH 02/32] Fix ellipse axes documentation to use semi-major/semi-minor Fixes #28530 --- .../py_gui/py_drawing_functions/py_drawing_functions.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/py_tutorials/py_gui/py_drawing_functions/py_drawing_functions.markdown b/doc/py_tutorials/py_gui/py_drawing_functions/py_drawing_functions.markdown index 4b7ff32e6d..d43cb104f9 100644 --- a/doc/py_tutorials/py_gui/py_drawing_functions/py_drawing_functions.markdown +++ b/doc/py_tutorials/py_gui/py_drawing_functions/py_drawing_functions.markdown @@ -52,7 +52,7 @@ cv.circle(img,(447,63), 63, (0,0,255), -1) ### Drawing Ellipse To draw the ellipse, we need to pass several arguments. One argument is the center location (x,y). -Next argument is axes lengths (major axis length, minor axis length). angle is the angle of rotation +Next argument is axes lengths (semi-major axis length, semi-minor axis length). angle is the angle of rotation of ellipse in anti-clockwise direction. startAngle and endAngle denotes the starting and ending of ellipse arc measured in clockwise direction from major axis. i.e. giving values 0 and 360 gives the full ellipse. For more details, check the documentation of **cv.ellipse()**. Below example draws a From 5ef5aab4354ca353c3a9e2ebe75a62b7dc3b1e29 Mon Sep 17 00:00:00 2001 From: Kumataro Date: Sun, 22 Feb 2026 07:58:04 +0900 Subject: [PATCH 03/32] imgproc: fix -Wstringop-overflow false-positive in minEnclosingConvexPolygon This commit addresses a compiler warning encountered when building with GCC 13 and C++20. The compiler triggers a false-positive -Wstringop-overflow warning in `findKSides`. By adding `sides.reserve(k)`, we explicitly inform the compiler about the required memory allocation, which suppresses the warning and provides a minor optimization by avoiding potential reallocations. --- modules/imgproc/src/min_enclosing_convex_polygon.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/modules/imgproc/src/min_enclosing_convex_polygon.cpp b/modules/imgproc/src/min_enclosing_convex_polygon.cpp index c97ada4abc..2f12b0e474 100644 --- a/modules/imgproc/src/min_enclosing_convex_polygon.cpp +++ b/modules/imgproc/src/min_enclosing_convex_polygon.cpp @@ -913,6 +913,7 @@ std::vector Chains::reconstructHSidedChain(int h, int i, int j) std::vector Chains::findKSides(int k, int i, int j) { std::vector sides; + sides.reserve(k); // Optimization and avoiding GCC's false positive warning (-Wstringop-overflow) sides.push_back({i, true}); sides.push_back({j, true}); From 1194bd24cb98a67069eb0bfba0677c7f12236126 Mon Sep 17 00:00:00 2001 From: hyndhavamahesh345 Date: Sun, 22 Feb 2026 14:11:17 +0530 Subject: [PATCH 04/32] docs: fix typos and missing parameter description in flann and calib3d --- modules/calib3d/include/opencv2/calib3d.hpp | 2 +- modules/flann/include/opencv2/flann.hpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp index 52d32e9613..560bc2ac8a 100644 --- a/modules/calib3d/include/opencv2/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d.hpp @@ -4094,7 +4094,7 @@ namespace fisheye the number of points in the view. @param imagePoints Output array of image points, 2xN/Nx2 1-channel or 1xN/Nx1 2-channel, or vector\. - @param affine + @param affine Pose of the camera. @param K Camera intrinsic matrix \f$\cameramatrix{K}\f$. @param D Input vector of distortion coefficients \f$\distcoeffsfisheye\f$. @param alpha The skew coefficient. diff --git a/modules/flann/include/opencv2/flann.hpp b/modules/flann/include/opencv2/flann.hpp index 90ee59e0b8..470fba1f9c 100644 --- a/modules/flann/include/opencv2/flann.hpp +++ b/modules/flann/include/opencv2/flann.hpp @@ -175,9 +175,9 @@ public: /** @brief Constructs a nearest neighbor search index for a given dataset. - @param features Matrix of containing the features(points) to index. The size of the matrix is + @param features Matrix containing the features(points) to index. The size of the matrix is num_features x feature_dimensionality and the data type of the elements in the matrix must - coincide with the type of the index. + match the type of the index. @param params Structure containing the index parameters. The type of index that will be constructed depends on the type of this parameter. See the description. @param distance From 261222ebf6239671e25f146f3a5d0c7d252b044c Mon Sep 17 00:00:00 2001 From: Adrian Kretz Date: Tue, 24 Feb 2026 10:21:57 +0100 Subject: [PATCH 05/32] Merge pull request #28562 from akretz:fix_ipp_warpAffine Fix IPP warpAffine #28562 The issue is that we compute the inverse transformation and pass that to the HAL, but tell IPP that we use the actual transformation. https://github.com/opencv/opencv/blob/a269a489b94b84717691533a04f79d9a0e5f479a/modules/imgproc/src/imgwarp.cpp#L2399-L2412 I have added an additional test with `CV_16S` Mats to test the IPP implementation, because right now no other `warpAffine` test enters the IPP branch. This fixes #28554. ### 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 --- hal/ipp/src/warp_ipp.cpp | 2 +- modules/imgproc/test/test_imgwarp.cpp | 27 +++++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 1 deletion(-) diff --git a/hal/ipp/src/warp_ipp.cpp b/hal/ipp/src/warp_ipp.cpp index fe283c4271..531698c0e0 100644 --- a/hal/ipp/src/warp_ipp.cpp +++ b/hal/ipp/src/warp_ipp.cpp @@ -112,7 +112,7 @@ int ipp_hal_warpAffine(int src_type, const uchar *src_data, size_t src_step, int iwSrc.Init({src_width, src_height}, ippiGetDataType(src_type), CV_MAT_CN(src_type), NULL, src_data, IwSize(src_step)); ::ipp::IwiImage iwDst({dst_width, dst_height}, ippiGetDataType(src_type), CV_MAT_CN(src_type), NULL, dst_data, dst_step); ::ipp::IwiBorderType ippBorder(ippiGetBorderType(borderType), {borderValue[0], borderValue[1], borderValue[2], borderValue[3]}); - IwTransDirection iwTransDirection = iwTransForward; + IwTransDirection iwTransDirection = iwTransInverse; if((int)ippBorder == -1) return CV_HAL_ERROR_NOT_IMPLEMENTED; diff --git a/modules/imgproc/test/test_imgwarp.cpp b/modules/imgproc/test/test_imgwarp.cpp index 3372380413..382b74de4d 100644 --- a/modules/imgproc/test/test_imgwarp.cpp +++ b/modules/imgproc/test/test_imgwarp.cpp @@ -1561,6 +1561,33 @@ TEST(Imgproc_Warp, regression_19566) // valgrind should detect problem if any } +TEST(Imgproc_Warp, regression_28554) +{ + const Size inSize(128, 128); + const Size outSize(256, 256); + + Mat inMat = Mat::ones(inSize, CV_16S); + Mat outMat = Mat(outSize, CV_16S); + Mat coeffs = Mat::eye(2, 3, CV_64F); + coeffs.at(0, 2) = 64.; + coeffs.at(1, 2) = 64.; + + warpAffine( + inMat, + outMat, + coeffs, + outSize, + INTER_NEAREST, + cv::BORDER_CONSTANT, + 0.0 + ); + + Mat reference = Mat::zeros(outSize, CV_16S); + reference(cv::Rect(64, 64, 128, 128)) = 1; + ASSERT_EQ(0.0, cvtest::norm(reference, outMat, NORM_INF)); +} + + TEST(Imgproc_GetAffineTransform, singularity) { Point2f A_sample[3]; From 5abe4678c168ee4f8b1d4341e7f63ac5d8a679a9 Mon Sep 17 00:00:00 2001 From: Andrew Owens Date: Wed, 25 Feb 2026 12:31:47 -1000 Subject: [PATCH 06/32] highgui(cocoa): fix moveWindow Y conversion when Dock is visible --- modules/highgui/src/window_cocoa.mm | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/modules/highgui/src/window_cocoa.mm b/modules/highgui/src/window_cocoa.mm index f14b45dab1..d68b20bd40 100644 --- a/modules/highgui/src/window_cocoa.mm +++ b/modules/highgui/src/window_cocoa.mm @@ -244,7 +244,8 @@ CV_IMPL void cvShowImage( const char* name, const CvArr* arr) int y = [window y0]; if(x >= 0 && y >= 0) { - y = [[window screen] visibleFrame].size.height - y; + NSRect visibleFrame = [[window screen] visibleFrame]; + y = NSMaxY(visibleFrame) - y; [window setFrameTopLeftPoint:NSMakePoint(x, y)]; } } @@ -285,7 +286,8 @@ CV_IMPL void cvMoveWindow( const char* name, int x, int y) [window setY0:y]; } else { - y = [[window screen] visibleFrame].size.height - y; + NSRect visibleFrame = [[window screen] visibleFrame]; + y = NSMaxY(visibleFrame) - y; [window setFrameTopLeftPoint:NSMakePoint(x, y)]; } } From c4ff523cf4881c2536f29b23589d6c46bbc5e635 Mon Sep 17 00:00:00 2001 From: Alexander Smorkalov Date: Thu, 26 Feb 2026 10:06:03 +0300 Subject: [PATCH 07/32] Test video url refresh. --- modules/videoio/test/test_ffmpeg.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/videoio/test/test_ffmpeg.cpp b/modules/videoio/test/test_ffmpeg.cpp index a8fdc39f8c..85c1cd5457 100644 --- a/modules/videoio/test/test_ffmpeg.cpp +++ b/modules/videoio/test/test_ffmpeg.cpp @@ -851,7 +851,7 @@ TEST(videoio_ffmpeg, DISABLED_open_from_web) if (!videoio_registry::hasBackend(CAP_FFMPEG)) throw SkipTestException("FFmpeg backend was not found"); - string video_file = "http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4"; + string video_file = "https://dl.opencv.org/data/BigBuckBunny.mp4"; VideoCapture cap(video_file, CAP_FFMPEG); int n_frames = -1; EXPECT_NO_THROW(n_frames = (int)cap.get(CAP_PROP_FRAME_COUNT)); From 6c374bebeece731190b2238a2cc831e0175aa0b0 Mon Sep 17 00:00:00 2001 From: Kumataro Date: Thu, 26 Feb 2026 17:01:36 +0900 Subject: [PATCH 08/32] Merge pull request #28519 from Kumataro:fix28503 imgcodecs(webp): improve IMWRITE_WEBP_LOSSLESS_MODE to support exact lossless compression #28519 Close #28503 Add IMWRITE_WEBP_LOSSLESS_MODE enum to control lossless strategy: - IMWRITE_WEBP_LOSSLESS_OFF: Lossy compression. - IMWRITE_WEBP_LOSSLESS_ON: Optimize/drop color in transparent pixels. - IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR: Preserve color in transparent pixels. Note: Currently limited to still images; animated WebP support is deferred per YAGNI. ### 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 --- .../imgcodecs/include/opencv2/imgcodecs.hpp | 11 +- modules/imgcodecs/src/grfmt_webp.cpp | 157 +++++++++++++++--- modules/imgcodecs/test/test_webp.cpp | 148 +++++++++++++++++ 3 files changed, 289 insertions(+), 27 deletions(-) diff --git a/modules/imgcodecs/include/opencv2/imgcodecs.hpp b/modules/imgcodecs/include/opencv2/imgcodecs.hpp index bad9f006b5..6c59d55ec3 100644 --- a/modules/imgcodecs/include/opencv2/imgcodecs.hpp +++ b/modules/imgcodecs/include/opencv2/imgcodecs.hpp @@ -102,7 +102,8 @@ enum ImwriteFlags { IMWRITE_EXR_TYPE = (3 << 4) + 0 /* 48 */, //!< override EXR storage type (FLOAT (FP32) is default) IMWRITE_EXR_COMPRESSION = (3 << 4) + 1 /* 49 */, //!< override EXR compression type (ZIP_COMPRESSION = 3 is default) IMWRITE_EXR_DWA_COMPRESSION_LEVEL = (3 << 4) + 2 /* 50 */, //!< override EXR DWA compression level (45 is default) - IMWRITE_WEBP_QUALITY = 64, //!< For WEBP, it can be a quality from 1 to 100 (the higher is the better). By default (without any parameter) and for quality above 100 the lossless compression is used. + IMWRITE_WEBP_QUALITY = 64, //!< For WEBP, it can be a lossy quality from 1 to 100 (the higher is the better) for IMWRITE_WEBP_LOSSLESS_OFF. By default (without this parameter) or if quality > 100, IMWRITE_WEBP_LOSSLESS_ON is used instead. + IMWRITE_WEBP_LOSSLESS_MODE = 65, //!< For WEBP, it can be a lossless compression strategy. See cv::ImwriteWEBPLosslessMode. Default is IMWRITE_WEBP_LOSSLESS_OFF. For Animated WEBP, it is not supported. IMWRITE_HDR_COMPRESSION = (5 << 4) + 0 /* 80 */, //!< specify HDR compression IMWRITE_PAM_TUPLETYPE = 128,//!< For PAM, sets the TUPLETYPE field to the corresponding string value that is defined for the format IMWRITE_TIFF_RESUNIT = 256,//!< For TIFF, use to specify which DPI resolution unit to set. See ImwriteTiffResolutionUnitFlags. Default is IMWRITE_TIFF_RESOLUTION_UNIT_INCH. @@ -240,6 +241,14 @@ enum ImwritePAMFlags { IMWRITE_PAM_FORMAT_RGB_ALPHA = 5 }; +//! Imwrite WEBP specific values for IMWRITE_WEBP_LOSSLESS_MODE parameter key. +enum ImwriteWEBPLosslessMode { + IMWRITE_WEBP_LOSSLESS_OFF = 0, //!< Lossy compression mode. Uses IMWRITE_WEBP_QUALITY to control compression. (Default) + //!< @note If IMWRITE_WEBP_QUALITY is not specified, it falls back to IMWRITE_WEBP_LOSSLESS_ON to maintain backward compatibility. + IMWRITE_WEBP_LOSSLESS_ON = 1, //!< Standard lossless compression. May modify or discard RGB values of fully transparent pixels to improve compression ratio. + IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR = 2, //!< Exact lossless compression. Preserves all RGB data even for pixels with 0 alpha (equivalent to WebP's exact flag). +}; + //! Imwrite HDR specific values for IMWRITE_HDR_COMPRESSION parameter key enum ImwriteHDRCompressionFlags { IMWRITE_HDR_COMPRESSION_NONE = 0, diff --git a/modules/imgcodecs/src/grfmt_webp.cpp b/modules/imgcodecs/src/grfmt_webp.cpp index 068be52b8b..a37bbfca54 100644 --- a/modules/imgcodecs/src/grfmt_webp.cpp +++ b/modules/imgcodecs/src/grfmt_webp.cpp @@ -338,7 +338,7 @@ WebPEncoder::WebPEncoder() m_support_metadata[IMAGE_METADATA_EXIF] = true; m_support_metadata[IMAGE_METADATA_XMP] = true; m_support_metadata[IMAGE_METADATA_ICCP] = true; - m_supported_encode_key = {IMWRITE_WEBP_QUALITY}; + m_supported_encode_key = {IMWRITE_WEBP_QUALITY, IMWRITE_WEBP_LOSSLESS_MODE}; } WebPEncoder::~WebPEncoder() { } @@ -348,32 +348,121 @@ ImageEncoder WebPEncoder::newEncoder() const return makePtr(); } +// Simple API style +static size_t cvEncodeLosslessExactBGRA(const uint8_t* rgba, int width, int height, int stride, uint8_t** output) +{ + WebPConfig config; + WebPPicture pic; + WebPMemoryWriter wrt; + + // 6 is the default value for speed/compression balance in lossless mode. + // It doesn't affect visual quality, only file size and encoding time. + if (!WebPConfigInit(&config) || !WebPConfigLosslessPreset(&config, 6)) + { + return 0; + } + config.exact = 1; + + if (!WebPPictureInit(&pic)) + { + return 0; + } + pic.width = width; + pic.height = height; + pic.use_argb = 1; // BGRA + if (!WebPPictureImportBGRA(&pic, rgba, stride)) + { + return 0; + } + + WebPMemoryWriterInit(&wrt); + pic.writer = WebPMemoryWrite; + pic.custom_ptr = &wrt; + + if (!WebPEncode(&config, &pic)) + { + WebPMemoryWriterClear(&wrt); + WebPPictureFree(&pic); + return 0; + } + + *output = wrt.mem; + size_t size = wrt.size; + WebPPictureFree(&pic); + return size; +} + bool WebPEncoder::write(const Mat& img, const std::vector& params) { CV_CheckDepthEQ(img.depth(), CV_8U, "WebP codec supports 8U images only"); const int width = img.cols, height = img.rows; - bool comp_lossless = true; - float quality = 100.0f; + int lossless_mode = -1; // not specified + float quality = 0.0f; // not specified for(size_t i = 0; i < params.size(); i += 2) { const int value = params[i+1]; - if (params[i] == IMWRITE_WEBP_QUALITY) + if (params[i] == IMWRITE_WEBP_LOSSLESS_MODE) { - comp_lossless = false; - quality = static_cast(value); - if (quality < 1.0f) + switch(value) { - quality = 1.0f; - CV_LOG_WARNING(nullptr, cv::format("The value(%d) for IMWRITE_WEBP_QUALITY must be between 1 to 100(lossy) or more(lossless). It is fallbacked to 1", value)); - } - if (quality > 100.0f) - { - comp_lossless = true; + case IMWRITE_WEBP_LOSSLESS_ON: + case IMWRITE_WEBP_LOSSLESS_OFF: + case IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR: + lossless_mode = value; + break; + default: + CV_LOG_WARNING(nullptr, cv::format("The value(%d) for IMWRITE_WEBP_LOSSLESS_MODE must be one of ImwriteWEBPLosslessMode. It is ignored", value)); + break; } } + if (params[i] == IMWRITE_WEBP_QUALITY) + { + if (value < 1) + { + CV_LOG_WARNING(nullptr, cv::format("The value(%d) for IMWRITE_WEBP_QUALITY must be between 1 to 100(lossy) or more(lossless). It is fallbacked to 1", value)); + quality = 1.0f; + } + else if (value > 100) + { + quality = 101.0f; + } + else // value is 1 to 100 + { + quality = static_cast(value); + } + } + } + + switch(lossless_mode) + { + case -1: // not specified by user + case IMWRITE_WEBP_LOSSLESS_OFF: + // Fallback to lossless if quality is not specified (-1.0f) or out of lossy range (>100.0f). + // This maintains backward compatibility where WebP defaults to lossless. + if ((quality < 1.0f) || (quality > 100.0f)) + { + lossless_mode = IMWRITE_WEBP_LOSSLESS_ON; + quality = 101.0f; + } + else + { + lossless_mode = IMWRITE_WEBP_LOSSLESS_OFF; + // Use specified quality for lossy compression. + } + break; + + case IMWRITE_WEBP_LOSSLESS_ON: + case IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR: + // Force quality value to lossless range when explicit lossless mode is selected. + quality = 101.0f; + break; + + default: + CV_Error(Error::StsError, cv::format("Unexpected lossless_mode(%d)", lossless_mode)); + break; } int channels = img.channels(); @@ -391,29 +480,45 @@ bool WebPEncoder::write(const Mat& img, const std::vector& params) uint8_t *encoder_out = NULL; size_t size = 0; - if (comp_lossless) + if (channels == 3) { - if (channels == 3) + switch(lossless_mode) { - size = WebPEncodeLosslessBGR(image->ptr(), width, height, (int)image->step, &encoder_out); - } - else if (channels == 4) - { - size = WebPEncodeLosslessBGRA(image->ptr(), width, height, (int)image->step, &encoder_out); + case IMWRITE_WEBP_LOSSLESS_OFF: + size = WebPEncodeBGR(image->ptr(), width, height, (int)image->step, quality, &encoder_out); + break; + case IMWRITE_WEBP_LOSSLESS_ON: + case IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR: + size = WebPEncodeLosslessBGR(image->ptr(), width, height, (int)image->step, &encoder_out); + break; + default: + CV_Error(Error::StsError, cv::format("Unexcepted lossless_mode(%d)", lossless_mode)); + break; } } else { - if (channels == 3) + CV_CheckEQ(channels, 4, "Unexpected channels is used"); + switch(lossless_mode) { - size = WebPEncodeBGR(image->ptr(), width, height, (int)image->step, quality, &encoder_out); - } - else if (channels == 4) - { - size = WebPEncodeBGRA(image->ptr(), width, height, (int)image->step, quality, &encoder_out); + case IMWRITE_WEBP_LOSSLESS_OFF: + size = WebPEncodeBGRA(image->ptr(), width, height, (int)image->step, quality, &encoder_out); + break; + case IMWRITE_WEBP_LOSSLESS_ON: + size = WebPEncodeLosslessBGRA(image->ptr(), width, height, (int)image->step, &encoder_out); + break; + case IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR: + size = cvEncodeLosslessExactBGRA(image->ptr(), width, height, (int)image->step, &encoder_out); + break; } } + if (size == 0) + { + CV_LOG_ERROR(NULL, cv::format("WebP encoding failed with lossless_mode=%d", lossless_mode)); + return false; + } + #if WEBP_DECODER_ABI_VERSION >= 0x0206 Ptr out_cleaner(encoder_out, WebPFree); #else diff --git a/modules/imgcodecs/test/test_webp.cpp b/modules/imgcodecs/test/test_webp.cpp index b3fe9b2caf..b016dbb40d 100644 --- a/modules/imgcodecs/test/test_webp.cpp +++ b/modules/imgcodecs/test/test_webp.cpp @@ -114,6 +114,154 @@ TEST(Imgcodecs_WebP, encode_decode_with_alpha_webp) EXPECT_EQ(512, img_webp_bgr.rows); } + +// See https://github.com/opencv/opencv/issues/28503 +TEST(Imgcodecs_WebP, encode_decode_LOSSLESS_MODE) +{ + cv::Mat img(cv::Size(64,4), CV_8UC4, cv::Scalar(124,64,67,0) ); + for(int ix = 0; ix < img.size().width; ix++) + { + img.at(0, ix)[3] = 0; // Transpacency pixel + img.at(1, ix)[3] = 1; + img.at(2, ix)[3] = 254; + img.at(3, ix)[3] = 255; + } + + std::vector work; + EXPECT_NO_THROW(cv::imencode(".webp", img, work, {IMWRITE_WEBP_LOSSLESS_MODE, IMWRITE_WEBP_LOSSLESS_ON})); + cv::Mat img_ON = cv::imdecode(work, IMREAD_UNCHANGED); + EXPECT_NO_THROW(cv::imencode(".webp", img, work, {IMWRITE_WEBP_LOSSLESS_MODE, IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR})); + cv::Mat img_PRESERVE_COLOR = cv::imdecode(work, IMREAD_UNCHANGED); + + for(int ix = 0; ix < img.size().width; ix++) + { + EXPECT_EQ(img_ON.at(0, ix), Vec4b(0, 0, 0, 0)); // LOSSLESS_ON -> COLOR will be optimized/dropped. + EXPECT_EQ(img_PRESERVE_COLOR.at(0, ix), Vec4b(124,64,67,0)); // PRESERVE_COLOR + + EXPECT_EQ(img_ON.at(1, ix), img_PRESERVE_COLOR.at(1, ix) ); + EXPECT_EQ(img_ON.at(2, ix), img_PRESERVE_COLOR.at(2, ix) ); + EXPECT_EQ(img_ON.at(3, ix), img_PRESERVE_COLOR.at(3, ix) ); + } +} + +// Expected result categories for WebP encoding tests. +enum ImencodeLosslessResult { + LOSSY, // Expect lossy compression (pixel differences allowed) + LOSSLESS, // Expect standard lossless compression (pixel values match) + EXACT // Expect exact lossless (preserving RGB values of transparent pixels) +}; + +typedef std::tuple WebPModePriorityParams; +class Imgcodecs_WebP_Mode_Priority : public testing::TestWithParam {}; + +TEST_P(Imgcodecs_WebP_Mode_Priority, encode_webp_mode_priority) +{ + const int mode = std::get<0>(GetParam()); + const int quality = std::get<1>(GetParam()); + const ImencodeLosslessResult expected = std::get<2>(GetParam()); + + // Generate a 100x100 RGBA test image. + // Set a transparent pixel with specific color (Blue) to verify EXACT mode. + Mat src(100, 100, CV_8UC4, Scalar(255, 255, 255, 255)); + src.at(0, 0) = Vec4b(255, 0, 0, 0); // Transparent Blue (B:255, G:0, R:0, A:0) + + // Build the imwrite parameter vector dynamically. + std::vector params; + if (mode != -1) { + params.push_back(IMWRITE_WEBP_LOSSLESS_MODE); + params.push_back(mode); + } + if (quality != -1) { + params.push_back(IMWRITE_WEBP_QUALITY); + params.push_back(quality); + } + + // Encode to memory and decode back. + std::vector buf; + ASSERT_TRUE(imencode(".webp", src, buf, params)); + Mat dst = imdecode(buf, IMREAD_UNCHANGED); + ASSERT_FALSE(dst.empty()); + + // Validation logic + if (expected == LOSSY) { + // We expect some differences in lossy mode + double diff = cv::norm(src, dst, NORM_INF); + EXPECT_GT(diff, 0) << "Should be lossy (Quality: " << quality << ")"; + } + else if (expected == LOSSLESS) { + // Standard lossless: we allow the library to modify RGB values + // of fully transparent pixels (A=0) to improve compression ratio. + // Thus, we compare only visible pixels or check with a slightly relaxed condition. + + // Option A: If you want to allow RGB changes on A=0: + // We can't use cv::norm directly if A=0 pixels are modified. + // Let's check if they are identical except for the transparent pixel. + Mat diff; + absdiff(src, dst, diff); + Scalar total_diff = sum(diff); + // If only the (0,0) pixel changed from (255,0,0,0) to (0,0,0,0), + // total_diff will be 255. + EXPECT_LE(total_diff[0] + total_diff[1] + total_diff[2], 255) + << "Standard lossless should not have significant pixel differences"; + EXPECT_EQ(src.at(0,0)[3], dst.at(0,0)[3]) << "Alpha must be preserved"; + } + else if (expected == EXACT) { + // Exact lossless: Every single bit must match, including transparent pixels. + double diff = cv::norm(src, dst, NORM_INF); + EXPECT_EQ(0, diff) << "Exact mode must preserve all pixel values perfectly"; + EXPECT_EQ(src.at(0, 0), dst.at(0, 0)) + << "RGB values of transparent pixels must be preserved in EXACT mode"; + } + else { + FAIL() << "Unknown expectation type"; + } +} + +/** + * Helper to generate human-readable test names in gtest output. + */ +static std::string getModeStr(int m) { + if (m == -1) return "OMIT"; + if (m == IMWRITE_WEBP_LOSSLESS_OFF) return "OFF"; + if (m == IMWRITE_WEBP_LOSSLESS_ON) return "ON"; + if (m == IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR) return "PRESERVE"; + return "UNKNOWN"; +} + +static std::string getExpectStr(ImencodeLosslessResult r) { + return (r == LOSSY) ? "LOSSY" : (r == EXACT) ? "EXACT" : "LOSSLESS"; +} + +INSTANTIATE_TEST_CASE_P(Imgcodecs, Imgcodecs_WebP_Mode_Priority, + testing::Values( + // Default (OMIT mode) cases + WebPModePriorityParams(-1, -1, LOSSLESS), + WebPModePriorityParams(-1, 80, LOSSY), + WebPModePriorityParams(-1, 101, LOSSLESS), + + // LOSSLESS_OFF (Explicitly off) + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_OFF, -1, LOSSLESS), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_OFF, 80, LOSSY), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_OFF, 101, LOSSLESS), + + // LOSSLESS_ON (Force lossless) + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_ON, -1, LOSSLESS), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_ON, 80, LOSSLESS), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_ON, 101, LOSSLESS), + + // PRESERVE_COLOR (Exact lossless) + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR, -1, EXACT), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR, 80, EXACT), + WebPModePriorityParams(IMWRITE_WEBP_LOSSLESS_PRESERVE_COLOR, 101, EXACT) + ), + [](const testing::TestParamInfo& info_) { + std::string mode = getModeStr(std::get<0>(info_.param)); + int q = std::get<1>(info_.param); + std::string q_str = (q == -1) ? "omit" : std::to_string(q); + return mode + "_q" + q_str + "_" + getExpectStr(std::get<2>(info_.param)); + } +); + #endif // HAVE_WEBP }} // namespace From 01320ab612299e801be7d4bf5b58362c091bf979 Mon Sep 17 00:00:00 2001 From: Alexander Smorkalov Date: Fri, 27 Feb 2026 09:30:16 +0300 Subject: [PATCH 09/32] Fixed cv::mul overflow for U16 type. --- modules/core/src/arithm.simd.hpp | 9 +++++++++ modules/core/test/test_arithm.cpp | 12 ++++++++++++ 2 files changed, 21 insertions(+) diff --git a/modules/core/src/arithm.simd.hpp b/modules/core/src/arithm.simd.hpp index 3b8ab1c48b..00e3fe21a4 100644 --- a/modules/core/src/arithm.simd.hpp +++ b/modules/core/src/arithm.simd.hpp @@ -1437,6 +1437,15 @@ struct op_mul { return saturate_cast(a * b); } }; +template +struct op_mul +{ + static inline Tvec r(const Tvec& a, const Tvec& b) + { return v_mul(a, b); } + static inline uint16_t r(uint16_t a, uint16_t b) + { return saturate_cast(static_cast(a) * static_cast(b)); } +}; + template struct op_mul_scale { diff --git a/modules/core/test/test_arithm.cpp b/modules/core/test/test_arithm.cpp index 3a7a54a050..8f5632673f 100644 --- a/modules/core/test/test_arithm.cpp +++ b/modules/core/test/test_arithm.cpp @@ -3411,4 +3411,16 @@ TEST_P(Core_LUT, accuracy_multi2) INSTANTIATE_TEST_CASE_P(/**/, Core_LUT, testing::Combine( LutIdxType::all(), LutMatType::all())); +TEST(Core_Arithm, mul_overflow_28557) +{ + uint16_t data[] = {5000, 60000, 5000, 60000, 5000, 60000}; + cv::Mat m(1, 6, CV_16U, data); + cv::Mat res = m.mul(m); + + for (int i = 0; i < 6; i++) + { + EXPECT_EQ(65535, res.at(0, i)); + } +} + }} // namespace From a9e13a5e8c9336ce21b3377990e0224729b169a5 Mon Sep 17 00:00:00 2001 From: JoyBoy900908 Date: Sat, 28 Feb 2026 20:50:54 +0800 Subject: [PATCH 10/32] core: fix UBSan function pointer type mismatch in countNonZero --- modules/core/src/count_non_zero.simd.hpp | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/modules/core/src/count_non_zero.simd.hpp b/modules/core/src/count_non_zero.simd.hpp index 9de616fe8a..26af0a8d71 100644 --- a/modules/core/src/count_non_zero.simd.hpp +++ b/modules/core/src/count_non_zero.simd.hpp @@ -66,8 +66,9 @@ static int countNonZero8u( const uchar* src, int len ) return nz; } -static int countNonZero16u( const ushort* src, int len ) +static int countNonZero16u( const uchar* src_ptr, int len ) { + const ushort* src = reinterpret_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -101,8 +102,9 @@ static int countNonZero16u( const ushort* src, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero32s( const int* src, int len ) +static int countNonZero32s( const uchar* src_ptr, int len ) { + const int* src = reinterpret_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -136,8 +138,9 @@ static int countNonZero32s( const int* src, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero32f( const float* src, int len ) +static int countNonZero32f( const uchar* src_ptr, int len ) { + const float* src = reinterpret_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -171,8 +174,9 @@ static int countNonZero32f( const float* src, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero64f( const double* src, int len ) +static int countNonZero64f( const uchar* src_ptr, int len ) { + const double* src = reinterpret_cast(src_ptr); int nz = 0, i = 0; #if (CV_SIMD_64F || CV_SIMD_SCALABLE_64F) v_int64 sum1 = vx_setzero_s64(); From 69bdcc93861cda196df935dd2975e6f1384ceced Mon Sep 17 00:00:00 2001 From: Muhammad Awais Date: Mon, 2 Mar 2026 11:43:56 +0500 Subject: [PATCH 11/32] Merge pull request #28536 from Sikandar1310291:fix/inrange-typing-28534 Fix inRange type signature to accept Scalar values #28536 Fixes #28534 The Python type signature for cv2.inRange was too restrictive, requiring MatLike for lowerb and upperb parameters. However, the C++ implementation accepts InputArray which includes Scalar values (tuples, floats, etc.). This caused type checkers to incorrectly flag valid code from official tutorials as type errors. Added make_matlike_or_scalar_arg() refinement function to create union types MatLike | Scalar for affected parameters, matching the C++ InputArray behavior. ### 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 --- .../typing_stubs_generation/api_refinement.py | 60 ++++++++++++++++++- 1 file changed, 59 insertions(+), 1 deletion(-) diff --git a/modules/python/src2/typing_stubs_generation/api_refinement.py b/modules/python/src2/typing_stubs_generation/api_refinement.py index 3019e67e96..f92c5c8ce1 100644 --- a/modules/python/src2/typing_stubs_generation/api_refinement.py +++ b/modules/python/src2/typing_stubs_generation/api_refinement.py @@ -8,7 +8,7 @@ from .nodes import (NamespaceNode, FunctionNode, OptionalTypeNode, TypeNode, ClassProperty, PrimitiveTypeNode, ASTNodeTypeNode, AggregatedTypeNode, CallableTypeNode, AnyTypeNode, TupleTypeNode, UnionTypeNode, ProtocolClassNode, - DictTypeNode, ClassTypeNode) + DictTypeNode, ClassTypeNode, AliasRefTypeNode) from .ast_utils import (find_function_node, SymbolName, for_each_function_overload) from .types_conversion import create_type_node @@ -376,6 +376,62 @@ def _find_argument_index(arguments: Sequence[FunctionNode.Arg], return None +def make_matlike_or_scalar_arg(*arg_names: str) -> Callable[[NamespaceNode, SymbolName], None]: + """Make arguments accept both MatLike and Scalar types. + + This is used for functions like inRange where the C++ InputArray parameter + can accept both Mat objects and Scalar values (tuples, floats, etc.). + + Example: cv2.inRange(img, (0, 0, 0), (255, 255, 255)) should be valid. + """ + def _make_matlike_or_scalar_arg(root_node: NamespaceNode, + function_symbol_name: SymbolName) -> None: + from .predefined_types import PREDEFINED_TYPES + + function = find_function_node(root_node, function_symbol_name) + for arg_name in arg_names: + found_overload_with_arg = False + + for overload in function.overloads: + arg_idx = _find_argument_index(overload.arguments, arg_name) + + # skip overloads without this argument + if arg_idx is None: + continue + + current_type = overload.arguments[arg_idx].type_node + + # Check if it's already a union or if it already includes Scalar + if isinstance(current_type, UnionTypeNode): + # Check if Scalar is already in the union + has_scalar = any( + isinstance(item, AliasRefTypeNode) and item.typename == "Scalar" + for item in current_type.items + ) + if has_scalar: + continue + # Add Scalar to existing union + scalar_ref = AliasRefTypeNode("Scalar") + current_type.items = current_type.items + (scalar_ref,) + else: + # Create a union of current type and Scalar + scalar_ref = AliasRefTypeNode("Scalar") + overload.arguments[arg_idx].type_node = UnionTypeNode( + f"{arg_name}_type", + (cast(TypeNode, current_type), scalar_ref) + ) + + found_overload_with_arg = True + + if not found_overload_with_arg: + raise RuntimeError( + f"Failed to find argument with name: '{arg_name}'" + f" in '{function_symbol_name.name}' overloads" + ) + + return _make_matlike_or_scalar_arg + + NODES_TO_REFINE = { SymbolName(("cv", ), (), "resize"): make_optional_arg("dsize"), SymbolName(("cv", ), (), "calcHist"): make_optional_arg("mask"), @@ -401,6 +457,8 @@ NODES_TO_REFINE = { SymbolName(("cv", "fisheye"), (), "initUndistortRectifyMap"): make_optional_arg("D"), SymbolName(("cv", ), (), "imread"): make_optional_none_return, SymbolName(("cv", ), (), "imdecode"): make_optional_none_return, + # Fix for issue #28534: inRange should accept Scalar for lowerb and upperb + SymbolName(("cv", ), (), "inRange"): make_matlike_or_scalar_arg("lowerb", "upperb"), } ERROR_CLASS_PROPERTIES = ( From 30aa3c9266c76d4d7d797eec9204b9d84663ec58 Mon Sep 17 00:00:00 2001 From: ekharkov Date: Mon, 2 Mar 2026 01:47:14 -0800 Subject: [PATCH 12/32] Revert "Disable IPP with AVX512 in cv::compare because of performance regression" --- modules/core/src/arithm_ipp.hpp | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/modules/core/src/arithm_ipp.hpp b/modules/core/src/arithm_ipp.hpp index 33ade50918..ed722113a7 100644 --- a/modules/core/src/arithm_ipp.hpp +++ b/modules/core/src/arithm_ipp.hpp @@ -283,40 +283,24 @@ inline IppCmpOp arithm_ipp_convert_cmp(int cmpop) inline int arithm_ipp_cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2, uchar* dst, size_t step, int width, int height, int cmpop) { - // perf regression with AVX512: https://github.com/opencv/opencv/issues/28251 - if (ippCPUID_AVX512F&cv::ipp::getIppFeatures()) - return 0; - ARITHM_IPP_CMP(ippiCompare_8u_C1R, src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(width, height)); } inline int arithm_ipp_cmp16u(const ushort* src1, size_t step1, const ushort* src2, size_t step2, uchar* dst, size_t step, int width, int height, int cmpop) { - // perf regression with AVX512: https://github.com/opencv/opencv/issues/28251 - if (ippCPUID_AVX512F&cv::ipp::getIppFeatures()) - return 0; - ARITHM_IPP_CMP(ippiCompare_16u_C1R, src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(width, height)); } inline int arithm_ipp_cmp16s(const short* src1, size_t step1, const short* src2, size_t step2, uchar* dst, size_t step, int width, int height, int cmpop) { - // perf regression with AVX512: https://github.com/opencv/opencv/issues/28251 - if (ippCPUID_AVX512F&cv::ipp::getIppFeatures()) - return 0; - ARITHM_IPP_CMP(ippiCompare_16s_C1R, src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(width, height)); } inline int arithm_ipp_cmp32f(const float* src1, size_t step1, const float* src2, size_t step2, uchar* dst, size_t step, int width, int height, int cmpop) { - // perf regression with AVX512: https://github.com/opencv/opencv/issues/28251 - if (ippCPUID_AVX512F&cv::ipp::getIppFeatures()) - return 0; - ARITHM_IPP_CMP(ippiCompare_32f_C1R, src1, (int)step1, src2, (int)step2, dst, (int)step, ippiSize(width, height)); } From 6676c04d7cb2347a9257f9bd0341335e1f85452f Mon Sep 17 00:00:00 2001 From: gideok Kim Date: Mon, 2 Mar 2026 21:31:57 +0900 Subject: [PATCH 13/32] imgproc: remove redundant fabs() in fitEllipseDirect In fitEllipseDirect, `double det = fabs(cv::determinant(M))` applies fabs() unnecessarily since the next line `if (fabs(det) > 1.0e-10)` already takes the absolute value. Remove the outer fabs() to avoid the redundant operation. --- modules/imgproc/src/shapedescr.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/imgproc/src/shapedescr.cpp b/modules/imgproc/src/shapedescr.cpp index 8d78f00f26..a713cfeed4 100644 --- a/modules/imgproc/src/shapedescr.cpp +++ b/modules/imgproc/src/shapedescr.cpp @@ -750,7 +750,7 @@ cv::RotatedRect cv::fitEllipseDirect( InputArray _points ) M(2,1) = (DM(0,1) + (DM(0,3)*TM(0,1) + DM(0,4)*TM(1,1) + DM(0,5)*TM(2,1))/Ts)/2.; M(2,2) = (DM(0,2) + (DM(0,3)*TM(0,2) + DM(0,4)*TM(1,2) + DM(0,5)*TM(2,2))/Ts)/2.; - double det = fabs(cv::determinant(M)); + double det = cv::determinant(M); if (fabs(det) > 1.0e-10) break; eps = (float)(s/(n*2)*1e-2); From 517bc1c777cd75f947e3ff705843bbbf5f331400 Mon Sep 17 00:00:00 2001 From: Vincent Rabaud Date: Mon, 2 Mar 2026 18:13:34 +0100 Subject: [PATCH 14/32] Make sure j < maxRow in smooth functions Otherwise some values out of memory can be read. This was found with ASAN. --- modules/imgproc/src/smooth.simd.hpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/imgproc/src/smooth.simd.hpp b/modules/imgproc/src/smooth.simd.hpp index 4bbd7722e6..6509ab532b 100644 --- a/modules/imgproc/src/smooth.simd.hpp +++ b/modules/imgproc/src/smooth.simd.hpp @@ -620,6 +620,8 @@ void inline smooth3N121Impl(const ET* src, int cn, ET *dst, int ito, int idst, int len = (width - offset) * cn; int x = offset * cn; int maxRow = min((ito - vOffset),height-vOffset); + if (v >= maxRow) return; + #if (CV_SIMD || CV_SIMD_SCALABLE) VFT v_8 = vx_setall((WET)8); const int VECSZ = VTraits::vlanes(); @@ -713,6 +715,7 @@ void inline smooth5N14641Impl(const ET* src, int cn, ET* dst, int ito, int idst, int len = (width - offset) * cn; int x = offset * cn; int maxRow = min((ito - vOffset),height-vOffset); + if (v >= maxRow) return; #if (CV_SIMD || CV_SIMD_SCALABLE) VFT v_6 = vx_setall((WET)6); From 1099135b88551897b19b207a4778f31b75f63901 Mon Sep 17 00:00:00 2001 From: ADITYA MISHRA <23104170@apsit.edu.in> Date: Tue, 3 Mar 2026 16:56:38 +0600 Subject: [PATCH 15/32] Merge pull request #28592 from AdityaMishra3000:fix-openvino-2026-constness DNN: Fix OpenVINO 2026 build failure due to ov::Tensor::data() const change #28592 Fixes: https://github.com/opencv/opencv/issues/28586 ### 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 ### PR Description OpenVINO 2026 changed ov::Tensor::data() to return `const void*` instead of `void*`. This causes a build error in modules/dnn/src/op_inf_engine.cpp when constructing a cv::Mat wrapper over Tensor memory. Tensor memory for input/output blobs remains mutable, but the API now enforces const-correct access. This patch casts away const with an explicit comment to preserve existing zero-copy semantics and restore compatibility with OpenVINO 2026. Preserves existing zero-copy semantics of the OpenVINO backend without altering runtime behavior. Tested by building OpenCV 4.x against OpenVINO 2026.0.0 on Ubuntu 24.04. --- modules/dnn/src/op_inf_engine.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/dnn/src/op_inf_engine.cpp b/modules/dnn/src/op_inf_engine.cpp index c95075c855..bc7e5ddc57 100644 --- a/modules/dnn/src/op_inf_engine.cpp +++ b/modules/dnn/src/op_inf_engine.cpp @@ -53,7 +53,7 @@ Mat infEngineBlobToMat(const ov::Tensor& blob) default: CV_Error(Error::StsNotImplemented, "Unsupported blob precision"); } - return Mat(size, type, blob.data()); + return Mat(size, type, const_cast(blob.data())); } void infEngineBlobsToMats(const ov::TensorVector& blobs, From 91c78f50647c0f342ac72bed3d5c8952fa9523ae Mon Sep 17 00:00:00 2001 From: Murat Raimbekov Date: Tue, 3 Mar 2026 17:29:47 +0600 Subject: [PATCH 16/32] Merge pull request #28309 from raimbekovm:fix-typos-batch6 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit docs: fix typos in documentation and code comments #28309 ## Summary This PR fixes 10 spelling errors in documentation and code comments across 7 files. ## Changes - `suppport` → `support` (2 occurrences in test_video_io.cpp) - `compability` → `compatibility` (2 occurrences in face.hpp) - `successfull` → `successful` (1 occurrence in cv2.cpp) - `accomodate` → `accommodate` (2 occurrences in calib3d.hpp and test_camera.cpp) - `minimun` → `minimum` (1 occurrence in aruco_detector.hpp) - `maximun` → `maximum` (1 occurrence in aruco_detector.hpp) - `orignal` → `original` (1 occurrence in aruco_detector.cpp) ## Test plan - [x] No API changes - [x] Documentation-only changes - [x] Code compiles without errors --- modules/calib3d/include/opencv2/calib3d.hpp | 2 +- modules/calib3d/test/test_stereomatching.cpp | 2 +- .../core/parallel/backend/parallel_for.tbb.hpp | 2 +- modules/core/test/test_operations.cpp | 6 +++--- modules/dnn/src/dnn_utils.cpp | 2 +- modules/dnn/src/layers/einsum_layer.cpp | 2 +- modules/dnn/src/layers/scatterND_layer.cpp | 2 +- modules/dnn/src/layers/scatter_layer.cpp | 2 +- modules/dnn/src/op_cann.cpp | 2 +- modules/dnn/src/op_timvx.cpp | 6 +++--- modules/dnn/src/op_timvx.hpp | 2 +- modules/gapi/include/opencv2/gapi/video.hpp | 2 +- modules/gapi/src/executor/gstreamingexecutor.cpp | 2 +- .../gapi/test/common/gapi_video_tests_common.hpp | 2 +- .../test/cpu/gapi_ocv_stateful_kernel_tests.cpp | 10 +++++----- modules/imgproc/include/opencv2/imgproc.hpp | 2 +- .../include/opencv2/objdetect/aruco_detector.hpp | 4 ++-- modules/python/src2/cv2.cpp | 2 +- modules/videoio/include/opencv2/videoio.hpp | 14 ++++++++++++-- .../include/opencv2/videoio/legacy/constants_c.h | 4 ++-- .../cap_obsensor/obsensor_stream_channel_msmf.cpp | 10 +++++----- .../cap_obsensor/obsensor_stream_channel_v4l2.cpp | 12 ++++++------ .../cap_obsensor/obsensor_uvc_stream_channel.hpp | 2 +- modules/videoio/test/test_camera.cpp | 2 +- 24 files changed, 54 insertions(+), 44 deletions(-) diff --git a/modules/calib3d/include/opencv2/calib3d.hpp b/modules/calib3d/include/opencv2/calib3d.hpp index 560bc2ac8a..9116491250 100644 --- a/modules/calib3d/include/opencv2/calib3d.hpp +++ b/modules/calib3d/include/opencv2/calib3d.hpp @@ -3874,7 +3874,7 @@ void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs, Size size, int m1type, OutputArray map1, OutputArray map2); /** @brief Computes the projection and inverse-rectification transformation map. In essense, this is the inverse of -#initUndistortRectifyMap to accomodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs. +#initUndistortRectifyMap to accommodate stereo-rectification of projectors ('inverse-cameras') in projector-camera pairs. The function computes the joint projection and inverse rectification transformation and represents the result in the form of maps for #remap. The projected image looks like a distorted version of the original which, diff --git a/modules/calib3d/test/test_stereomatching.cpp b/modules/calib3d/test/test_stereomatching.cpp index 826c4c8a3b..9ea16110b1 100644 --- a/modules/calib3d/test/test_stereomatching.cpp +++ b/modules/calib3d/test/test_stereomatching.cpp @@ -219,7 +219,7 @@ void computeOcclusionBasedMasks( const Mat& leftDisp, const Mat& _rightDisp, } /* - Calculate depth discontinuty regions: pixels whose neiboring disparities differ by more than + Calculate depth discontinuity regions: pixels whose neighboring disparities differ by more than dispGap, dilated by window of width discontWidth. */ void computeDepthDiscontMask( const Mat& disp, Mat& depthDiscontMask, const Mat& unknDispMask = Mat(), diff --git a/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp b/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp index 04b0c4c6cb..3c272d7862 100644 --- a/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp +++ b/modules/core/include/opencv2/core/parallel/backend/parallel_for.tbb.hpp @@ -13,7 +13,7 @@ #endif #include "tbb/tbb.h" #if !defined(TBB_INTERFACE_VERSION) -#error "Unknows/unsupported TBB version" +#error "Unknown/unsupported TBB version" #endif #if TBB_INTERFACE_VERSION >= 8000 diff --git a/modules/core/test/test_operations.cpp b/modules/core/test/test_operations.cpp index 9dfc030b2e..5486bbb39e 100644 --- a/modules/core/test/test_operations.cpp +++ b/modules/core/test/test_operations.cpp @@ -69,7 +69,7 @@ protected: bool TestSparseMat(); bool TestVec(); bool TestMatxMultiplication(); - bool TestMatxElementwiseDivison(); + bool TestMatxElementwiseDivision(); bool TestDivisionByValue(); bool TestInplaceDivisionByValue(); bool TestMatMatxCastSum(); @@ -957,7 +957,7 @@ bool CV_OperationsTest::TestMatMatxCastSum() return true; } -bool CV_OperationsTest::TestMatxElementwiseDivison() +bool CV_OperationsTest::TestMatxElementwiseDivision() { try { @@ -1248,7 +1248,7 @@ void CV_OperationsTest::run( int /* start_from */) if (!TestMatxMultiplication()) return; - if (!TestMatxElementwiseDivison()) + if (!TestMatxElementwiseDivision()) return; if (!TestDivisionByValue()) diff --git a/modules/dnn/src/dnn_utils.cpp b/modules/dnn/src/dnn_utils.cpp index b6f1d3fcce..5cc1359b0d 100644 --- a/modules/dnn/src/dnn_utils.cpp +++ b/modules/dnn/src/dnn_utils.cpp @@ -187,7 +187,7 @@ void blobFromImagesNCHWImpl(const std::vector& images, Mat& blob_, const Im if (param.mean == Scalar() && param.scalefactor == Scalar::all(1.0)) return; - CV_CheckTypeEQ(param.ddepth, CV_32F, "Scaling and mean substraction is supported only for CV_32F blob depth"); + CV_CheckTypeEQ(param.ddepth, CV_32F, "Scaling and mean subtraction is supported only for CV_32F blob depth"); for (size_t k = 0; k < images.size(); ++k) { diff --git a/modules/dnn/src/layers/einsum_layer.cpp b/modules/dnn/src/layers/einsum_layer.cpp index ff1062badb..b215fd749a 100644 --- a/modules/dnn/src/layers/einsum_layer.cpp +++ b/modules/dnn/src/layers/einsum_layer.cpp @@ -1179,7 +1179,7 @@ Mat LayerEinsumImpl::pairwiseOperandProcess( shape(currentLeft), reshaped_dims)) { - // This can be done because curent_* tensors (if they exist) and output tensors are + // This can be done because current_* tensors (if they exist) and output tensors are // intermediate tensors and cannot be input tensors to the Einsum node itself // (which are immutable). currentLeft = currentLeft.reshape(1, reshaped_dims.size(), reshaped_dims.data()); diff --git a/modules/dnn/src/layers/scatterND_layer.cpp b/modules/dnn/src/layers/scatterND_layer.cpp index e64cbfae3e..a4623614ea 100644 --- a/modules/dnn/src/layers/scatterND_layer.cpp +++ b/modules/dnn/src/layers/scatterND_layer.cpp @@ -39,7 +39,7 @@ public: else if (reduction_name == "min") reduction = REDUCTION::MIN; else - CV_Error(cv::Error::StsBadArg, "Unkown reduction \"" + reduction_name + "\""); + CV_Error(cv::Error::StsBadArg, "Unknown reduction \"" + reduction_name + "\""); } virtual bool supportBackend(int backendId) CV_OVERRIDE diff --git a/modules/dnn/src/layers/scatter_layer.cpp b/modules/dnn/src/layers/scatter_layer.cpp index 58d2c2daea..015c22bb0b 100644 --- a/modules/dnn/src/layers/scatter_layer.cpp +++ b/modules/dnn/src/layers/scatter_layer.cpp @@ -40,7 +40,7 @@ public: else if (reduction_name == "min") reduction = REDUCTION::MIN; else - CV_Error(cv::Error::StsBadArg, "Unkown reduction \"" + reduction_name + "\""); + CV_Error(cv::Error::StsBadArg, "Unknown reduction \"" + reduction_name + "\""); } virtual bool supportBackend(int backendId) CV_OVERRIDE diff --git a/modules/dnn/src/op_cann.cpp b/modules/dnn/src/op_cann.cpp index c36633dc15..ca6876eb44 100644 --- a/modules/dnn/src/op_cann.cpp +++ b/modules/dnn/src/op_cann.cpp @@ -215,7 +215,7 @@ void CannNet::forward() ACL_CHECK_RET(aclmdlExecute(model_id, inputs, outputs)); CV_LOG_DEBUG(NULL, "DNN/CANN: finished network forward"); - // fetch ouputs from device to host + // fetch outputs from device to host CV_LOG_DEBUG(NULL, "DNN/CANN: start fetching outputs to host"); for (size_t i = 0; i < output_wrappers.size(); ++i) { diff --git a/modules/dnn/src/op_timvx.cpp b/modules/dnn/src/op_timvx.cpp index 4d1bbbc884..1d94007781 100644 --- a/modules/dnn/src/op_timvx.cpp +++ b/modules/dnn/src/op_timvx.cpp @@ -535,7 +535,7 @@ TimVXBackendNode::TimVXBackendNode(const Ptr& tvGraph_, } TimVXBackendNode::TimVXBackendNode(const Ptr& tvGraph_, std::shared_ptr& op_, - std::vector& inputsIndex, std::vector& outpusIndex) + std::vector& inputsIndex, std::vector& outputsIndex) :BackendNode(DNN_BACKEND_TIMVX) { tvGraph = tvGraph_; @@ -545,8 +545,8 @@ TimVXBackendNode::TimVXBackendNode(const Ptr& tvGraph_, std::shared_ if (!inputsIndex.empty()) inputIndexList.assign(inputsIndex.begin(), inputsIndex.end()); - if (!outpusIndex.empty()) - outputIndexList.assign(outpusIndex.begin(), outpusIndex.end()); + if (!outputsIndex.empty()) + outputIndexList.assign(outputsIndex.begin(), outputsIndex.end()); } bool TimVXBackendNode::opBinding() diff --git a/modules/dnn/src/op_timvx.hpp b/modules/dnn/src/op_timvx.hpp index d08cf64bb5..ad37ec8575 100644 --- a/modules/dnn/src/op_timvx.hpp +++ b/modules/dnn/src/op_timvx.hpp @@ -96,7 +96,7 @@ public: TimVXBackendNode(const Ptr& tvGraph); TimVXBackendNode(const Ptr& tvGraph, const std::shared_ptr& op); TimVXBackendNode(const Ptr& tvGraph, std::shared_ptr& op, - std::vector& inputsIndex, std::vector& outpusIndex); + std::vector& inputsIndex, std::vector& outputsIndex); void setInputTensor(); bool opBinding(); diff --git a/modules/gapi/include/opencv2/gapi/video.hpp b/modules/gapi/include/opencv2/gapi/video.hpp index 4dcc1d4182..25e8e3d26e 100644 --- a/modules/gapi/include/opencv2/gapi/video.hpp +++ b/modules/gapi/include/opencv2/gapi/video.hpp @@ -355,7 +355,7 @@ template<> struct CompileArgTag { static const char* tag() { - return "org.opencv.video.background_substractor_params"; + return "org.opencv.video.background_subtractor_params"; } }; } // namespace detail diff --git a/modules/gapi/src/executor/gstreamingexecutor.cpp b/modules/gapi/src/executor/gstreamingexecutor.cpp index 67ad18dfa2..1a11467129 100644 --- a/modules/gapi/src/executor/gstreamingexecutor.cpp +++ b/modules/gapi/src/executor/gstreamingexecutor.cpp @@ -337,7 +337,7 @@ void rewindToStop(std::vector &in_queues, }); if (expected_stop_count > 0) { - // NB: it requires to substract own queues id from total waiting queue count + // NB: it requires to subtract own queues id from total waiting queue count // because it had got stop message before rewind was called expected_stop_count--; } diff --git a/modules/gapi/test/common/gapi_video_tests_common.hpp b/modules/gapi/test/common/gapi_video_tests_common.hpp index 0f755439c2..4a6c3e8574 100644 --- a/modules/gapi/test/common/gapi_video_tests_common.hpp +++ b/modules/gapi/test/common/gapi_video_tests_common.hpp @@ -381,7 +381,7 @@ inline void testBackgroundSubtractorStreaming(cv::GStreamingCompiled& gapiBackSu compare_f cmpF = AbsSimilarPoints(tolerance, numDiff).to_compare_f(); - // Comparison of G-API and OpenCV substractors + // Comparison of G-API and OpenCV subtractors std::size_t frames = 0u; while (frames <= testNumFrames && gapiBackSub.pull(cv::gout(frame, gapiForeground))) { diff --git a/modules/gapi/test/cpu/gapi_ocv_stateful_kernel_tests.cpp b/modules/gapi/test/cpu/gapi_ocv_stateful_kernel_tests.cpp index b8c7baa8f3..0c3588a452 100644 --- a/modules/gapi/test/cpu/gapi_ocv_stateful_kernel_tests.cpp +++ b/modules/gapi/test/cpu/gapi_ocv_stateful_kernel_tests.cpp @@ -37,7 +37,7 @@ namespace cv { static const char* tag() { - return "org.opencv.test.background_substractor_state_params"; + return "org.opencv.test.background_subtractor_state_params"; } }; @@ -115,7 +115,7 @@ namespace } }; - G_TYPED_KERNEL(GBackSub, , "org.opencv.test.background_substractor") + G_TYPED_KERNEL(GBackSub, , "org.opencv.test.background_subtractor") { static GMatDesc outMeta(GMatDesc in) { return in.withType(CV_8U, 1); } }; @@ -438,10 +438,10 @@ namespace gapiBackSub.start(); EXPECT_TRUE(gapiBackSub.running()); - // OpenCV reference substractor + // OpenCV reference subtractor auto pOCVBackSub = createBackgroundSubtractorKNN(); - // Comparison of G-API and OpenCV substractors + // Comparison of G-API and OpenCV subtractors std::size_t frames = 0u; while (gapiBackSub.pull(cv::gout(frame, gapiForeground))) { pOCVBackSub->apply(frame, ocvForeground, -1); @@ -503,7 +503,7 @@ TEST(StatefulKernel, StateIsChangedViaCompArgsOnReshape) const auto pkg = cv::gapi::kernels(); - // OpenCV reference substractor + // OpenCV reference subtractor auto pOCVBackSubKNN = createBackgroundSubtractorKNN(); auto pOCVBackSubMOG2 = createBackgroundSubtractorMOG2(); diff --git a/modules/imgproc/include/opencv2/imgproc.hpp b/modules/imgproc/include/opencv2/imgproc.hpp index ccaa78e31c..5e5f7cbd6e 100644 --- a/modules/imgproc/include/opencv2/imgproc.hpp +++ b/modules/imgproc/include/opencv2/imgproc.hpp @@ -3867,7 +3867,7 @@ CV_EXPORTS_W void demosaicing(InputArray src, OutputArray dst, int code, int dst The function computes moments, up to the 3rd order, of a vector shape or a rasterized shape. The results are returned in the structure cv::Moments. -@param array Single chanel raster image (CV_8U, CV_16U, CV_16S, CV_32F, CV_64F) or an array ( +@param array Single channel raster image (CV_8U, CV_16U, CV_16S, CV_32F, CV_64F) or an array ( \f$1 \times N\f$ or \f$N \times 1\f$ ) of 2D points (Point or Point2f). @param binaryImage If it is true, all non-zero image pixels are treated as 1's. The parameter is used for images only. diff --git a/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp b/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp index 9f3e28c511..61c8a00827 100644 --- a/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp +++ b/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp @@ -168,12 +168,12 @@ struct CV_EXPORTS_W_SIMPLE DetectorParameters { */ CV_PROP_RW double maxErroneousBitsInBorderRate; - /** @brief minimun standard deviation in pixels values during the decodification step to apply Otsu + /** @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 maximun error correction capability for each dictionary (default 0.6). + /// 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. diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp index b7df25e510..306559f0e3 100644 --- a/modules/python/src2/cv2.cpp +++ b/modules/python/src2/cv2.cpp @@ -226,7 +226,7 @@ static PyObject* createSubmodule(PyObject* parent_module, const std::string& nam } /// Populates parent module dictionary. Submodule lifetime should be managed /// by the global modules dictionary and parent module dictionary, so Py_DECREF after - /// successfull call to the `PyDict_SetItemString` is redundant. + /// successful call to the `PyDict_SetItemString` is redundant. if (PyDict_SetItemString(parent_module_dict, submodule_name.c_str(), submodule) < 0) { return PyErr_Format(PyExc_ImportError, "Can't register a submodule '%s' (full name: '%s')", diff --git a/modules/videoio/include/opencv2/videoio.hpp b/modules/videoio/include/opencv2/videoio.hpp index 34e95421f8..6b7b25c6f9 100644 --- a/modules/videoio/include/opencv2/videoio.hpp +++ b/modules/videoio/include/opencv2/videoio.hpp @@ -614,9 +614,19 @@ enum { CAP_PROP_IOS_DEVICE_FOCUS = 9001, enum { CAP_PROP_GIGA_FRAME_OFFSET_X = 10001, CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002, CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003, - CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004, + CAP_PROP_GIGA_FRAME_HEIGHT_MAX = 10004, +// Typo in pre-5.x sources. Remain for source compatibility +#if CV_VERSION_MAJOR <= 4 + CAP_PROP_GIGA_FRAME_HEIGH_MAX = CAP_PROP_GIGA_FRAME_HEIGHT_MAX, //!< @deprecated +#endif + CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005, - CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006 + CAP_PROP_GIGA_FRAME_SENS_HEIGHT = 10006 +// Typo in pre-5.x sources. Remain for source compatibility +#if CV_VERSION_MAJOR <= 4 + , + CAP_PROP_GIGA_FRAME_SENS_HEIGH = CAP_PROP_GIGA_FRAME_SENS_HEIGHT //!< @deprecated +#endif }; //! @} Smartek diff --git a/modules/videoio/include/opencv2/videoio/legacy/constants_c.h b/modules/videoio/include/opencv2/videoio/legacy/constants_c.h index 6bdcc2690b..bda8945d3b 100644 --- a/modules/videoio/include/opencv2/videoio/legacy/constants_c.h +++ b/modules/videoio/include/opencv2/videoio/legacy/constants_c.h @@ -342,9 +342,9 @@ enum CV_CAP_PROP_GIGA_FRAME_OFFSET_X = 10001, CV_CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002, CV_CAP_PROP_GIGA_FRAME_WIDTH_MAX = 10003, - CV_CAP_PROP_GIGA_FRAME_HEIGH_MAX = 10004, + CV_CAP_PROP_GIGA_FRAME_HEIGHT_MAX = 10004, CV_CAP_PROP_GIGA_FRAME_SENS_WIDTH = 10005, - CV_CAP_PROP_GIGA_FRAME_SENS_HEIGH = 10006, + CV_CAP_PROP_GIGA_FRAME_SENS_HEIGHT = 10006, CV_CAP_PROP_INTELPERC_PROFILE_COUNT = 11001, CV_CAP_PROP_INTELPERC_PROFILE_IDX = 11002, diff --git a/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp b/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp index 18c6f4782d..7681469d9d 100644 --- a/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp +++ b/modules/videoio/src/cap_obsensor/obsensor_stream_channel_msmf.cpp @@ -373,7 +373,7 @@ void MSMFStreamChannel::start(const StreamProfile& profile, FrameCallback frameC break; } } - streamState_ = quit ? streamState_ : STREAM_STOPED; + streamState_ = quit ? streamState_ : STREAM_STOPPED; } void MSMFStreamChannel::stop() @@ -385,7 +385,7 @@ void MSMFStreamChannel::stop() streamReader_->Flush(currentStreamIndex_); std::unique_lock lk(streamStateMutex_); streamStateCv_.wait_for(lk, std::chrono::milliseconds(1000), [&]() { - return streamState_ == STREAM_STOPED; + return streamState_ == STREAM_STOPPED; }); } } @@ -474,7 +474,7 @@ STDMETHODIMP MSMFStreamChannel::OnReadSample(HRESULT hrStatus, DWORD dwStreamInd streamStateCv_.notify_all(); } - if (streamState_ != STREAM_STOPPING && streamState_ != STREAM_STOPED) + if (streamState_ != STREAM_STOPPING && streamState_ != STREAM_STOPPED) { HR_FAILED_LOG(streamReader_->ReadSample(dwStreamIndex, 0, nullptr, nullptr, nullptr, nullptr)); if (sample) @@ -505,10 +505,10 @@ STDMETHODIMP MSMFStreamChannel::OnEvent(DWORD /*sidx*/, IMFMediaEvent* /*event*/ STDMETHODIMP MSMFStreamChannel::OnFlush(DWORD) { - if (streamState_ != STREAM_STOPED) + if (streamState_ != STREAM_STOPPED) { std::unique_lock lock(streamStateMutex_); - streamState_ = STREAM_STOPED; + streamState_ = STREAM_STOPPED; streamStateCv_.notify_all(); } return S_OK; diff --git a/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp b/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp index 0764ac3ace..2bc3b67250 100644 --- a/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp +++ b/modules/videoio/src/cap_obsensor/obsensor_stream_channel_v4l2.cpp @@ -176,7 +176,7 @@ Ptr V4L2Context::createStreamChannel(const UvcDeviceInfo& devInf V4L2StreamChannel::V4L2StreamChannel(const UvcDeviceInfo &devInfo) : IUvcStreamChannel(devInfo), devFd_(-1), - streamState_(STREAM_STOPED) + streamState_(STREAM_STOPPED) { devFd_ = open(devInfo_.id.c_str(), O_RDWR | O_NONBLOCK, 0); @@ -203,7 +203,7 @@ V4L2StreamChannel::~V4L2StreamChannel() noexcept void V4L2StreamChannel::start(const StreamProfile& profile, FrameCallback frameCallback) { - if (streamState_ != STREAM_STOPED) + if (streamState_ != STREAM_STOPPED) { CV_LOG_ERROR(NULL, devInfo_.id << ": repetitive operation!") return; @@ -248,7 +248,7 @@ void V4L2StreamChannel::start(const StreamProfile& profile, FrameCallback frameC streamState_ = STREAM_STARTING; uint32_t type = V4L2_BUF_TYPE_VIDEO_CAPTURE; IOCTL_FAILED_EXEC(xioctl(devFd_, VIDIOC_STREAMON, &type), { - streamState_ = STREAM_STOPED; + streamState_ = STREAM_STOPPED; for (uint32_t i = 0; i < MAX_FRAME_BUFFER_NUM; i++) { if (frameBuffList[i].ptr) @@ -279,7 +279,7 @@ void V4L2StreamChannel::grabFrame() IOCTL_FAILED_EXEC(xioctl(devFd_, VIDIOC_QBUF, &buf), { std::unique_lock lk(streamStateMutex_); - streamState_ = STREAM_STOPED; + streamState_ = STREAM_STOPPED; streamStateCv_.notify_all(); return; }); @@ -303,7 +303,7 @@ void V4L2StreamChannel::grabFrame() IOCTL_FAILED_CONTINUE(xioctl(devFd_, VIDIOC_QBUF, &buf)); } std::unique_lock lk(streamStateMutex_); - streamState_ = STREAM_STOPED; + streamState_ = STREAM_STOPPED; streamStateCv_.notify_all(); } @@ -357,7 +357,7 @@ void V4L2StreamChannel::stop() streamState_ = STREAM_STOPPING; std::unique_lock lk(streamStateMutex_); streamStateCv_.wait_for(lk, std::chrono::milliseconds(1000), [&](){ - return streamState_ == STREAM_STOPED; + return streamState_ == STREAM_STOPPED; }); uint32_t type = V4L2_BUF_TYPE_VIDEO_CAPTURE; IOCTL_FAILED_LOG(xioctl(devFd_, VIDIOC_STREAMOFF, &type)); diff --git a/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp b/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp index d967f928d8..1ad7f95e55 100644 --- a/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp +++ b/modules/videoio/src/cap_obsensor/obsensor_uvc_stream_channel.hpp @@ -42,7 +42,7 @@ struct UvcDeviceInfo enum StreamState { - STREAM_STOPED = 0, // stoped or ready + STREAM_STOPPED = 0, // stopped or ready STREAM_STARTING = 1, STREAM_STARTED = 2, STREAM_STOPPING = 3, diff --git a/modules/videoio/test/test_camera.cpp b/modules/videoio/test/test_camera.cpp index 30592b2932..441582c7cd 100644 --- a/modules/videoio/test/test_camera.cpp +++ b/modules/videoio/test/test_camera.cpp @@ -55,7 +55,7 @@ static void test_readFrames(/*const*/ VideoCapture& capture, const int N = 100, // Check that the time between two camera frames and two system time calls // are within 1.5 frame periods of one another. // - // 1.5x is chosen to accomodate for a dropped frame, and an additional 50% + // 1.5x is chosen to accommodate for a dropped frame, and an additional 50% // to account for drift in the scale of the camera and system time domains. EXPECT_NEAR(sysTimeElapsedSecs, camTimeElapsedSecs, framePeriod * 1.5); } From 5e91b461bc2d86775234242c21ec1e5369eb9c74 Mon Sep 17 00:00:00 2001 From: Jonas Perolini <74473718+JonasPerolini@users.noreply.github.com> Date: Wed, 4 Mar 2026 06:44:28 +0100 Subject: [PATCH 17/32] Merge pull request #28289 from JonasPerolini:pr-aruco-identification Identify ArUco markers based on threshold to reduce false positives #28289 **Goal:** parametrize the current marker identification process (pixel-based majority count) to reduce the number of false positives while maintaining high recall. Useful in high risk scenarios in which false positives are not acceptable. **Context:** This PR builds on top of https://github.com/opencv/opencv/pull/23190 in which we've introduced a pixel-based confidence in the marker detection. **Solution:** Include a new parameter: `validBitIdThreshold` used to identify markers based on the pixel count of each cell. Set the parameter default either to 50% which is equivalent to the current majority count implementation or to 49% which already singnificantly reduces the number of false positives (see details below). **Test coverage:** - Unit tests: `CV_ArucoDetectionThreshold`, `CV_InvertedArucoDetectionThreshold` - The impact of `validBitIdThreshold` on false positives was also tested using the benchmark dataset: `MIRFLICKR-25k` https://www.kaggle.com/datasets/skfrost19/mirflickr25k which contains random images without any markers. Every marker detection is a false positive. Example of images in the dataset: ![im2048](https://github.com/user-attachments/assets/3e38796b-67ce-44be-a91d-2fd268414515) ![im17627](https://github.com/user-attachments/assets/37253b9f-829d-4bac-b9fc-c844d16f546e) **Results:** A threshold of 49% already allows to significantly reduce the number of false positives for the dict `DICT_4X4_1000`: - `5942` false positives for `validBitIdThreshold = 0.5` - `629` false positives for `validBitIdThreshold = 0.49` and `0.46` - number of false positives divided by `9.5` when compared to `validBitIdThreshold = 0.5` - `139` false positives for `validBitIdThreshold = 0.43` and `0.4` - number of false positives divided by `42` when compared to `validBitIdThreshold = 0.5` Dicts with a higher number of cells are not as impacted since it's much harder to obtain false positives. However, the less cells in a marker the further away it can be reliably detected, so the dict `DICT_4X4_1000` is commonly used. false_positive_image_rate In the image attached, the values of `validBitIdThreshold` tested are: `0.10f, 0.20f, 0.30f, 0.40f, 0.43f, 0.46f, 0.49f, 0.50f, 0.53f, 0.56f, 0.60f, 0.70f, 0.80f, 0.90f` Summary of the results: [summary.csv](https://github.com/user-attachments/files/24315662/summary.csv) Note that we can also analyse the number of false positives per marker `id`. For example, here's the histogram for the dict `DICT_4X4_1000`. (The CSV attached contains all the results) false_positive_ids_DICT_4X4_1000_thr0 50 For example, the marker id 17 is detected 252 times with `validBitIdThreshold = 0.5` and only 34 times with `validBitIdThreshold = 0.49`. Looking at marker 17 (see below), we understand that this simple pattern randomly occurs in images. Marker17 Results for every dict and every `validBitIdThreshold` [per_id.csv](https://github.com/user-attachments/files/24315667/per_id.csv) **Missing coverage:** there is no labeled dataset with images containing markers to analyse the impact of on the recall (i.e. look at the true positive rate). For my specific use case (drones) any threshold above `0.4` allows to maintain a high recall in all conditions. ### 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 - [ ] 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 --- .../opencv2/objdetect/aruco_detector.hpp | 8 +- .../opencv2/objdetect/aruco_dictionary.hpp | 10 ++ .../misc/python/test/test_objdetect_aruco.py | 1 + .../objdetect/src/aruco/aruco_detector.cpp | 95 +++++------ .../objdetect/src/aruco/aruco_dictionary.cpp | 58 +++++-- .../objdetect/test/test_aruco_tutorial.cpp | 1 + .../objdetect/test/test_arucodetection.cpp | 151 +++++++++++++++++- .../objdetect/test/test_boarddetection.cpp | 1 + 8 files changed, 259 insertions(+), 66 deletions(-) diff --git a/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp b/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp index 61c8a00827..bf15437aa9 100644 --- a/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp +++ b/modules/objdetect/include/opencv2/objdetect/aruco_detector.hpp @@ -20,6 +20,8 @@ enum CornerRefineMethod{ 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 { @@ -49,7 +51,7 @@ struct CV_EXPORTS_W_SIMPLE DetectorParameters { aprilTagQuadSigma = 0.0; aprilTagMinClusterPixels = 5; aprilTagMaxNmaxima = 10; - aprilTagCriticalRad = (float)(10* CV_PI /180); + aprilTagCriticalRad = (float)(10 * CV_PI / 180); aprilTagMaxLineFitMse = 10.0; aprilTagMinWhiteBlackDiff = 5; aprilTagDeglitch = 0; @@ -57,6 +59,7 @@ struct CV_EXPORTS_W_SIMPLE DetectorParameters { 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()). @@ -231,6 +234,9 @@ struct CV_EXPORTS_W_SIMPLE DetectorParameters { /// 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 diff --git a/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp b/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp index 5f6fae64df..d918e08129 100644 --- a/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp +++ b/modules/objdetect/include/opencv2/objdetect/aruco_dictionary.hpp @@ -65,6 +65,12 @@ class CV_EXPORTS_W_SIMPLE Dictionary { */ 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 @@ -84,6 +90,10 @@ class CV_EXPORTS_W_SIMPLE Dictionary { /** @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; }; diff --git a/modules/objdetect/misc/python/test/test_objdetect_aruco.py b/modules/objdetect/misc/python/test/test_objdetect_aruco.py index 45ffcf3241..10dffad514 100644 --- a/modules/objdetect/misc/python/test/test_objdetect_aruco.py +++ b/modules/objdetect/misc/python/test/test_objdetect_aruco.py @@ -323,6 +323,7 @@ class aruco_objdetect_test(NewOpenCVTests): imgSize = (500, 500) params = cv.aruco.DetectorParameters() params.minDistanceToBorder = 3 + params.validBitIdThreshold = 0.5 board = cv.aruco.CharucoBoard((4, 4), 0.03, 0.015, cv.aruco.getPredefinedDictionary(cv.aruco.DICT_6X6_250)) detector = cv.aruco.CharucoDetector(board, detectorParams=params) diff --git a/modules/objdetect/src/aruco/aruco_detector.cpp b/modules/objdetect/src/aruco/aruco_detector.cpp index 48b9ead516..434e709810 100644 --- a/modules/objdetect/src/aruco/aruco_detector.cpp +++ b/modules/objdetect/src/aruco/aruco_detector.cpp @@ -310,12 +310,11 @@ static void _detectInitialCandidates(const Mat &grey, vector > & /** - * @brief Given an input image and candidate corners, extract the bits of the candidate, including + * @brief Given an input image and candidate corners, extract the cell pixel ratio of the candidate, including * the border bits */ -static Mat _extractBits(InputArray _image, const vector& corners, int markerSize, - int markerBorderBits, int cellSize, double cellMarginRate, double minStdDevOtsu, - OutputArray _cellPixelRatio = noArray()) { +static Mat _extractCellPixelRatio(InputArray _image, const vector& 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); @@ -339,11 +338,11 @@ static Mat _extractBits(InputArray _image, const vector& corners, int m warpPerspective(_image, resultImg, transformation, Size(resultImgSize, resultImgSize), INTER_NEAREST); - // output image containing the bits - Mat bits(markerSizeWithBorders, markerSizeWithBorders, CV_8UC1, Scalar::all(0)); + // 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 bits are the same color (black or white) + // 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) @@ -351,18 +350,13 @@ static Mat _extractBits(InputArray _image, const vector& corners, int m 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) - bits.setTo(1); - else - bits.setTo(0); - if(_cellPixelRatio.needed()) bits.convertTo(_cellPixelRatio, CV_32F); - return bits; - } + if(mean.ptr< double >(0)[0] > 127){ + cellPixelRatio.setTo(1); + } else { + cellPixelRatio.setTo(0); + } - Mat cellPixelRatio; - if (_cellPixelRatio.needed()) { - _cellPixelRatio.create(markerSizeWithBorders, markerSizeWithBorders, CV_32FC1); - cellPixelRatio = _cellPixelRatio.getMatRef(); + return cellPixelRatio; } // now extract code, first threshold using Otsu @@ -377,38 +371,40 @@ static Mat _extractBits(InputArray _image, const vector& corners, int m cellSize - 2 * cellMarginPixels)); // count white pixels on each cell to assign its value size_t nZ = (size_t) countNonZero(square); - if(nZ > square.total() / 2) bits.at(y, x) = 1; // define the cell pixel ratio as the ratio of the white pixels. For inverted markers, the ratio will be inverted. - if(_cellPixelRatio.needed()) cellPixelRatio.at(y, x) = (nZ / (float)square.total()); + cellPixelRatio.at(y, x) = (nZ / (float)square.total()); } } - return bits; + return cellPixelRatio; } /** - * @brief Return number of erroneous bits in border, i.e. number of white bits in border. + * @brief Return number of erroneous bits in border, i.e. bits for which pixel ratio > validBitIdThreshold. */ -static int _getBorderErrors(const Mat &bits, int markerSize, int borderSize) { + static int _getBorderErrors(const Mat &cellPixelRatio, int markerSize, int borderSize, float validBitIdThreshold) { int sizeWithBorders = markerSize + 2 * borderSize; - CV_Assert(markerSize > 0 && bits.cols == sizeWithBorders && bits.rows == sizeWithBorders); + 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++) { - if(bits.ptr(y)[k] != 0) totalErrors++; - if(bits.ptr(y)[sizeWithBorders - 1 - k] != 0) totalErrors++; + // Left and right vertical sides + if(cellPixelRatio.ptr(y)[k] > validBitIdThreshold) totalErrors++; + if(cellPixelRatio.ptr(y)[sizeWithBorders - 1 - k] > validBitIdThreshold) totalErrors++; } } for(int x = borderSize; x < sizeWithBorders - borderSize; x++) { for(int k = 0; k < borderSize; k++) { - if(bits.ptr(k)[x] != 0) totalErrors++; - if(bits.ptr(sizeWithBorders - 1 - k)[x] != 0) totalErrors++; + // Top and bottom horizontal sides + if(cellPixelRatio.ptr(k)[x] > validBitIdThreshold) totalErrors++; + if(cellPixelRatio.ptr(sizeWithBorders - 1 - k)[x] > validBitIdThreshold) totalErrors++; } } return totalErrors; @@ -482,49 +478,43 @@ static uint8_t _identifyOneCandidate(const Dictionary& dictionary, const Mat& _i scaled_corners[i].y = _corners[i].y * scale; } - Mat cellPixelRatio; - Mat candidateBits = - _extractBits(_image, scaled_corners, dictionary.markerSize, params.markerBorderBits, - params.perspectiveRemovePixelPerCell, - params.perspectiveRemoveIgnoredMarginPerCell, params.minOtsuStdDev, - cellPixelRatio); + 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(dictionary.markerSize * dictionary.markerSize * params.maxErroneousBitsInBorderRate); int borderErrors = - _getBorderErrors(candidateBits, dictionary.markerSize, params.markerBorderBits); + _getBorderErrors(cellPixelRatio, dictionary.markerSize, params.markerBorderBits, params.validBitIdThreshold); // check if it is a white marker if(params.detectInvertedMarker){ - // to get from 255 to 1 - Mat invertedImg = ~candidateBits-254; - int invBError = _getBorderErrors(invertedImg, dictionary.markerSize, params.markerBorderBits); + Mat invCellPixelRatio = 1.f - cellPixelRatio; + int invBError = _getBorderErrors(invCellPixelRatio, dictionary.markerSize, params.markerBorderBits, params.validBitIdThreshold); // white marker if(invBError maximumErrorsInBorder) return 0; // border is wrong // take only inner bits - Mat onlyBits = - candidateBits.rowRange(params.markerBorderBits, - candidateBits.rows - params.markerBorderBits) - .colRange(params.markerBorderBits, candidateBits.cols - params.markerBorderBits); + Mat onlyCellPixelRatio = + cellPixelRatio.rowRange(params.markerBorderBits, + cellPixelRatio.rows - params.markerBorderBits) + .colRange(params.markerBorderBits, cellPixelRatio.cols - params.markerBorderBits); - // try to indentify the marker - if(!dictionary.identify(onlyBits, idx, rotation, params.errorCorrectionRate)) + // 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; - Mat bitsUints = dictionary.getBitsFromByteList(dictionary.bytesList.rowRange(idx, idx + 1), dictionary.markerSize, rotation); - bitsUints.convertTo(groundTruthbits, CV_32F); + Mat groundTruthbits = dictionary.getMarkerBits(idx, rotation); markerConfidence = _getMarkerConfidence(groundTruthbits, cellPixelRatio, dictionary.markerSize, params.markerBorderBits); } @@ -1403,11 +1393,14 @@ void ArucoDetector::refineDetectedMarkers(InputArray _image, const Board& _board if(refineParams.errorCorrectionRate >= 0) { // extract bits - Mat bits = _extractBits( + 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); diff --git a/modules/objdetect/src/aruco/aruco_dictionary.cpp b/modules/objdetect/src/aruco/aruco_dictionary.cpp index 350ccc63eb..7dfdcc3009 100644 --- a/modules/objdetect/src/aruco/aruco_dictionary.cpp +++ b/modules/objdetect/src/aruco/aruco_dictionary.cpp @@ -73,25 +73,32 @@ void Dictionary::writeDictionary(FileStorage& fs, const String &name) } -bool Dictionary::identify(const Mat &onlyBits, int &idx, int &rotation, double maxCorrectionRate) const { - CV_Assert(onlyBits.rows == markerSize && onlyBits.cols == markerSize); +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); - // get as a byte list - Mat candidateBytes = getByteListFromBits(onlyBits); - 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(unsigned int r = 0; r < 4; r++) { - int currentHamming = cv::hal::normHamming( - bytesList.ptr(m)+r*candidateBytes.cols, - candidateBytes.ptr(), - candidateBytes.cols); + 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(i, j) - static_cast(bitsRot.at(i, j))) > validBitIdThreshold){ + currentHamming++; + } + } + } if(currentHamming < currentMinDistance) { currentMinDistance = currentHamming; @@ -111,6 +118,16 @@ bool Dictionary::identify(const Mat &onlyBits, int &idx, int &rotation, double m } +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); @@ -147,7 +164,8 @@ void Dictionary::generateImageMarker(int id, int sidePixels, OutputArray _img, i Mat innerRegion = tinyMarker.rowRange(borderBits, tinyMarker.rows - borderBits) .colRange(borderBits, tinyMarker.cols - borderBits); // put inner bits - Mat bits = 255 * getBitsFromByteList(bytesList.rowRange(id, id + 1), markerSize); + Mat bits = getMarkerBits(id); + bits.convertTo(bits, CV_8U, 255.0); CV_Assert(innerRegion.total() == bits.total()); bits.copyTo(innerRegion); @@ -194,12 +212,28 @@ Mat Dictionary::getByteListFromBits(const Mat &bits) { } +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(rotationId >=0 && rotationId < 4); + CV_Assert(byteList.channels() >= 4); + CV_Assert(rotationId >= 0 && rotationId < 4); Mat bits(markerSize, markerSize, CV_8UC1, Scalar::all(0)); diff --git a/modules/objdetect/test/test_aruco_tutorial.cpp b/modules/objdetect/test/test_aruco_tutorial.cpp index 182c6a2cdc..686633504d 100644 --- a/modules/objdetect/test/test_aruco_tutorial.cpp +++ b/modules/objdetect/test/test_aruco_tutorial.cpp @@ -189,6 +189,7 @@ TEST(CV_ArucoTutorial, can_find_diamondmarkers) aruco::DetectorParameters detectorParams; detectorParams.readDetectorParameters(fs.root()); detectorParams.cornerRefinementMethod = aruco::CORNER_REFINE_APRILTAG; + detectorParams.validBitIdThreshold = 0.5f; aruco::CharucoBoard charucoBoard(Size(3, 3), 0.4f, 0.25f, dictionary); aruco::CharucoDetector detector(charucoBoard, aruco::CharucoParameters(), detectorParams); diff --git a/modules/objdetect/test/test_arucodetection.cpp b/modules/objdetect/test/test_arucodetection.cpp index d40bef6582..53f4302cc0 100644 --- a/modules/objdetect/test/test_arucodetection.cpp +++ b/modules/objdetect/test/test_arucodetection.cpp @@ -473,7 +473,7 @@ markerDetectionGT applyTemperingToMarkerCells(cv::Mat &marker, ++cellsTempered; // cell too tempered, no detection expected - if(cellTempConfig.cellRatioToTemper > 0.5f) { + if(cellTempConfig.cellRatioToTemper > params.validBitIdThreshold) { if(isBorder){ ++borderErrors; } else { @@ -556,7 +556,7 @@ static void runArucoDetectionConfidence(ArucoAlgParams arucoAlgParam) { // make sure there are no bits have any detection errors params.maxErroneousBitsInBorderRate = 0.0; params.errorCorrectionRate = 0.0; - params.perspectiveRemovePixelPerCell = 8; // esnsure that there is enough resolution to properly handle distortions + params.perspectiveRemovePixelPerCell = 8; // ensure that there is enough resolution to properly handle distortions aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_6X6_250), params); const bool detectInvertedMarker = (arucoAlgParam == ArucoAlgParams::DETECT_INVERTED_MARKER); @@ -674,6 +674,144 @@ static void runArucoDetectionConfidence(ArucoAlgParams arucoAlgParam) { } } + +// Helper struc and functions for CV_ArucoDetectionUnc +struct ArucoThresholdTestConfig { + MarkerTemperingConfig markerTemperingConfig; // Configuration of cells to invert (percentage, number and markerRegionToTemper) + float validBitIdThreshold; // range [0,1], define the acceptable threshold when comparing the detected marker to the dictionary during marker identification. + float perspectiveRemoveIgnoredMarginPerCell; // Width of the margin of pixels on each cell not considered for the marker identification + int markerBorderBits; // Number of bits of the marker border + float distortionRatio; // Percentage of offset used for perspective distortion, bigger means more distorted +}; + +/** + * @brief Test the param validBitIdThreshold + * Loops over a set of detector configurations (validBitIdThreshold, distortion, DetectorParameters such as markerBorderBits) + * For each configuration, it creates a synthetic image containing four markers arranged in a 2x2 grid. + * Each marker is generated with its own configuration (id, size, rotation). + * Make sure that markers are detected or not based on validBitIdThreshold and percentage of tempering. + * Finally, it runs the detector and checks that each marker is detected or not based on the threshold. + * + */ +static void runArucoDetectionThreshold(ArucoAlgParams arucoAlgParam) { + + aruco::DetectorParameters params; + // make sure there are no bits have any detection errors + params.perspectiveRemovePixelPerCell = 20; // ensure that there is enough resolution to properly handle distortions + params.maxErroneousBitsInBorderRate = 0.f; + params.errorCorrectionRate = 0.f; + aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_5X5_250), params); // Max correction: 6bits + + const bool detectInvertedMarker = (arucoAlgParam == ArucoAlgParams::DETECT_INVERTED_MARKER); + + // define several detector configurations to test different settings + // {{MarkerTemperingConfig}, validBitIdThreshold, perspectiveRemoveIgnoredMarginPerCell, markerBorderBits, distortionRatio} + + vector detectorConfigs = { + // No tempering, expect detection for every threshold + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.3f, 0.f, 1, 0.f}, + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.5f, 0.f, 1, 0.f}, + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.9f, 0.f, 1, 0.f}, + // Include distortions + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.3f, 0.f, 1, 0.05f}, + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.5f, 0.f, 1, 0.1f}, + {{0.f, 0, MarkerRegionToTemper::ALL}, 0.9f, 0.f, 1, 0.2f}, + + // 20% temper, expect detection with threshold above 0.2 + {{0.2f, 5, MarkerRegionToTemper::BORDER}, 0.30f, 0.f, 1, 0.f}, // Detection + + {{0.2f, 1, MarkerRegionToTemper::BORDER}, 0.18f, 0.f, 1, 0.f}, // No detection + {{0.2f, 1, MarkerRegionToTemper::BORDER}, 0.18f, 0.f, 1, 0.f}, // No detection + {{0.2f, 10, MarkerRegionToTemper::INNER}, 0.22f, 0.f, 1, 0.f}, // Detection + {{0.2f, 1, MarkerRegionToTemper::INNER}, 0.18f, 0.f, 1, 0.f} // No detection + + // distortions + }; + + // define marker configurations for the 4 markers in each image + const int markerSidePixels = 700; // To simplify the cell division, markerSidePixels is a multiple of 7. (5x5 dict + 2 border bits) + vector markerCreationConfig = { + {0, markerSidePixels, markerRot::ROT_90}, // {id, markerSidePixels, rotation} + {1, markerSidePixels, markerRot::ROT_270}, + {2, markerSidePixels, markerRot::NONE}, + {3, markerSidePixels, markerRot::ROT_180} + }; + + // loop over each detector configuration + for (size_t cfgIdx = 0; cfgIdx < detectorConfigs.size(); cfgIdx++) { + ArucoThresholdTestConfig detCfg = detectorConfigs[cfgIdx]; + + // update detector parameters + params.validBitIdThreshold =detCfg.validBitIdThreshold; + params.perspectiveRemoveIgnoredMarginPerCell = detCfg.perspectiveRemoveIgnoredMarginPerCell; + params.markerBorderBits = detCfg.markerBorderBits; + params.detectInvertedMarker = detectInvertedMarker; + detector.setDetectorParameters(params); + + // create a blank image large enough to hold 4 markers in a 2x2 grid + const int margin = markerSidePixels / 2; + const int imageSize = (markerSidePixels * 2) + margin * 3; + Mat img(imageSize, imageSize, CV_8UC1, Scalar(255)); + + vector groundTruths; + const aruco::Dictionary &dictionary = detector.getDictionary(); + + // place each marker into the image + for (int row = 0; row < 2; row++) { + for (int col = 0; col < 2; col++) { + int index = row * 2 + col; + MarkerCreationConfig markerCfg = markerCreationConfig[index]; + // adjust marker id to be unique for each detector configuration + markerCfg.id += static_cast(cfgIdx * markerCreationConfig.size()); + + // generate img + Mat markerImg; + markerDetectionGT gt = generateTemperedMarkerImage(markerImg, markerCfg, detCfg.markerTemperingConfig, params, dictionary, detCfg.distortionRatio); + + groundTruths.push_back(gt); + + // place marker in the image + Point2f topLeft(static_cast(margin + col * (markerSidePixels + margin)), + static_cast(margin + row * (markerSidePixels + margin))); + placeMarker(img, markerImg, topLeft); + } + } + + // if testing inverted markers globally, invert the whole image + if (detectInvertedMarker) { + bitwise_not(img, img); + } + + // run detection. + vector> corners, rejected; + vector ids; + vector markerConfidence; + detector.detectMarkersWithConfidence(img, corners, ids, markerConfidence, rejected); + + ASSERT_EQ(ids.size(), corners.size()); + ASSERT_EQ(ids.size(), markerConfidence.size()); + + std::map confidenceById; + for (size_t i = 0; i < ids.size(); i++) { + confidenceById[ids[i]] = markerConfidence[i]; + } + + // verify that every marker is detected and its confidence is within tolerance + for (const auto& currentGT : groundTruths) { + const auto it = confidenceById.find(currentGT.id); + const bool detected = it != confidenceById.end(); + EXPECT_EQ(currentGT.expectDetection, detected) + << "Marker id: " << currentGT.id << " (detector config " << cfgIdx << ")"; + + if (currentGT.expectDetection && detected) { + EXPECT_NEAR(currentGT.confidence, it->second, 0.05) + << "Marker id: " << currentGT.id << " (detector config " << cfgIdx << ")"; + } + } + } +} + + /** * @brief Check max and min size in marker detection parameters */ @@ -981,6 +1119,14 @@ TEST(CV_InvertedFlagArucoDetectionConfidence, algorithmic) { } } +TEST(CV_ArucoDetectionThreshold, algorithmic) { + runArucoDetectionThreshold(ArucoAlgParams::USE_DEFAULT); +} + +TEST(CV_InvertedArucoDetectionThreshold, algorithmic) { + runArucoDetectionThreshold(ArucoAlgParams::DETECT_INVERTED_MARKER); +} + TEST(CV_ArucoDetectMarkers, regression_3192) { aruco::ArucoDetector detector(aruco::getPredefinedDictionary(aruco::DICT_4X4_50)); @@ -1304,6 +1450,7 @@ TEST_P(ArucoThreading, number_of_threads_does_not_change_results) aruco::DetectorParameters detectorParameters = detector.getDetectorParameters(); detectorParameters.cornerRefinementMethod = (int)GetParam(); + detectorParameters.validBitIdThreshold = 0.5f; detector.setDetectorParameters(detectorParameters); vector > original_corners; diff --git a/modules/objdetect/test/test_boarddetection.cpp b/modules/objdetect/test/test_boarddetection.cpp index 312bb5b56b..f95413ab32 100644 --- a/modules/objdetect/test/test_boarddetection.cpp +++ b/modules/objdetect/test/test_boarddetection.cpp @@ -66,6 +66,7 @@ void CV_ArucoBoardPose::run(int) { vector > corners; vector ids; detectorParameters.markerBorderBits = markerBorder; + detectorParameters.validBitIdThreshold = 0.5f; detector.setDetectorParameters(detectorParameters); detector.detectMarkers(img, corners, ids); From fe160f3eed3ec0344baff4bfb6a0771d01b5882d Mon Sep 17 00:00:00 2001 From: Anshu Date: Wed, 4 Mar 2026 17:46:07 +0530 Subject: [PATCH 18/32] Merge pull request #28548 from 0AnshuAditya0:fix-minEnclosingCircle-welzl-28546 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit imgproc: fix minEnclosingCircle O(n^3) worst case by adding Welzl shuffle #28548 Welzl's algorithm requires random permutation of input points to achieve expected O(n) time. Without shuffling, sorted inputs such as those produced by findContours() trigger O(n^3) worst case. Fix: copy input to std::vector and apply cv::randShuffle() before processing. Uses OpenCV's RNG so cv::setRNGSeed() ensures reproducible behavior. Original benchmark (5088 contour points, Release, AVX2): findContours output: 3.93 ms → 0.033 ms (119x speedup) Random points: 0.051 ms → 0.049 ms (no regression) Perf test results (this PR, Release, AVX2): | Input | N | Time | |-------|---|------| | Sequential circle points | 10000 | 0.03 ms | | Sequential circle points | 5000 | 0.01 ms | | Random points (CV_32F) | 100000 | 1.87 ms | | Random points (CV_32S) | 100000 | 2.81 ms | Fixes #28546 ### 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 --- modules/imgproc/perf/perf_contours.cpp | 35 ++++++++++++++++++++++++++ modules/imgproc/src/shapedescr.cpp | 25 +++++++++++++++++- 2 files changed, 59 insertions(+), 1 deletion(-) diff --git a/modules/imgproc/perf/perf_contours.cpp b/modules/imgproc/perf/perf_contours.cpp index bc8b530016..8fabdb334b 100644 --- a/modules/imgproc/perf/perf_contours.cpp +++ b/modules/imgproc/perf/perf_contours.cpp @@ -106,4 +106,39 @@ PERF_TEST_P(TestBoundingRect, BoundingRect, SANITY_CHECK_NOTHING(); } +typedef TestBaseWithParam< tuple > TestMinEnclosingCircle; +PERF_TEST_P(TestMinEnclosingCircle, minEnclosingCircle, + Combine( + testing::Values(CV_32S, CV_32F), + Values(400, 1000, 10000, 100000) + )) +{ + int ptType = get<0>(GetParam()); + int n = get<1>(GetParam()); + Mat pts(n, 2, ptType); + declare.in(pts, WARMUP_RNG); + + Point2f center; + float radius; + TEST_CYCLE() minEnclosingCircle(pts, center, radius); + SANITY_CHECK_NOTHING(); +} + +typedef TestBaseWithParam TestMinEnclosingCircleWorstCase; +PERF_TEST_P(TestMinEnclosingCircleWorstCase, minEnclosingCircle_sequential, + Values(400, 1000, 5000, 10000)) +{ + int n = GetParam(); + vector contour; + for(int i = 0; i < n; ++i) { + float angle = (float)(i * 2 * CV_PI / n); + contour.push_back(Point2f(cos(angle) * 100, sin(angle) * 100)); + } + + Point2f center; + float radius; + TEST_CYCLE() minEnclosingCircle(contour, center, radius); + SANITY_CHECK_NOTHING(); +} + } } // namespace diff --git a/modules/imgproc/src/shapedescr.cpp b/modules/imgproc/src/shapedescr.cpp index a713cfeed4..6ddd855e32 100644 --- a/modules/imgproc/src/shapedescr.cpp +++ b/modules/imgproc/src/shapedescr.cpp @@ -130,8 +130,31 @@ void findSecondPoint(const PT *pts, int i, Point2f ¢er, float &radius) template -static void findMinEnclosingCircle(const PT *pts, int count, Point2f ¢er, float &radius) +static void findMinEnclosingCircle(const PT *pts_in, int count, Point2f ¢er, float &radius) { + // Welzl's algorithm requires random permutation for expected O(n) time. + // Without shuffling, sorted inputs trigger O(n^3) worst case. + cv::AutoBuffer pts_buf(count); + std::copy(pts_in, pts_in + count, pts_buf.data()); + PT* pts = pts_buf.data(); + if (count > 10) + { + Cv32suf x0, y0, xn, yn; + x0.f = (float)pts[0].x; + y0.f = (float)pts[0].y; + xn.f = (float)pts[count-1].x; + yn.f = (float)pts[count-1].y; + + uint32_t seed = (uint32_t)count ^ x0.u ^ (y0.u << 8) ^ (xn.u << 16) ^ (yn.u << 24); + cv::RNG rng(seed); + + for (int i = 1; i < count; ++i) + { + int j = rng.uniform(0, i + 1); + std::swap(pts[i], pts[j]); + } + } + center.x = (float)(pts[0].x + pts[1].x) / 2.0f; center.y = (float)(pts[0].y + pts[1].y) / 2.0f; float dx = (float)(pts[0].x - pts[1].x); From 7f164b5653a47a0e7f645cab18947f920dfaf05d Mon Sep 17 00:00:00 2001 From: Souriya Trinh Date: Thu, 5 Mar 2026 11:05:07 +0100 Subject: [PATCH 19/32] Add a white background for images which have a transparent background in the calib3d module. See: - https://github.com/opencv/opencv/pull/28450 - https://github.com/opencv/opencv/pull/28426 --- modules/calib3d/doc/pics/hand-eye_figure.png | Bin 21200 -> 36331 bytes .../calib3d/doc/pics/pinhole_camera_model.png | Bin 26262 -> 74003 bytes .../pinhole_homogeneous_transformation.jpg | Bin 0 -> 79362 bytes .../pinhole_homogeneous_transformation.png | Bin 79039 -> 0 bytes .../doc/pics/robot-world_hand-eye_figure.png | Bin 23978 -> 39694 bytes modules/calib3d/include/opencv2/calib3d.hpp | 12 ++++++------ 6 files changed, 6 insertions(+), 6 deletions(-) create mode 100644 modules/calib3d/doc/pics/pinhole_homogeneous_transformation.jpg delete mode 100644 modules/calib3d/doc/pics/pinhole_homogeneous_transformation.png diff --git a/modules/calib3d/doc/pics/hand-eye_figure.png b/modules/calib3d/doc/pics/hand-eye_figure.png index ff41d33f8c6a49a3b32f5c6928958881a649136b..0d53be4bdf774a743709dbf5fb7c40998cd3ea11 100644 GIT binary patch literal 36331 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 DA2t)? literal 21200 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 s5FKb`hPF4q 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 _z192)9gh8SWbN{)R8))4@ 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 YmdMTa7fquV5xFZbcT6^Mzs~jl0mvz~zW@LL literal 26262 zcmZs?1yodF+cr9Mi*$p4v~(k(T%u~>c0A5{7`Ql0cUuwM9U%ur5`#d@$nlBHYxgbl zbrRy;^QTw|?IX@rad8X}v{Zc{IFS2KlxIp=XL)*TkOt^Y&i64Q(3=*}&lFlP@TDKl zpCl!j4fJ6Q0hC0AON#8j1P?M>G7yCWjg)kH!-3KsKw>B$e3TD)y*`^Nt2cfycu$WPZ^QU z0rW}&Ygz)Y{=@qpA$HBEb8GZVA@>~UN*__DPDu&Z5Z=+Eic9XHA|!lFe(fSj#3?Nh zj1O?tKHX2TmyI_5#wAUxxXc?NR0{@=BZo&qdCSlC|ocbl#?Zpu3HHmf$X zeGxl`v%_ujzmF{5+&*h{mun{zMWhNF?;=`fIUBuEe875O^d)@``0%C%H3QKpkcB!q z9y~A0NJmcR{JIJ^6iqc)iY9?kVwz3|uOlKs60SB}OF>wnU7Va+5l<|!Fjv&E}=2OUCNv7@&~%txF@6j_RM zKNlyu_u%h*Jux1I9t9usQ6(e|dKBL3d<_Fvg1--h50I(+DrsfZbWXC!wkX^aobbxK zF#gJk#fef2u01ktFed8h>m}?Z*^u5?*NTee$0fy8#GSwm!DV<`B`43x z5z5>h&}H(^jEB>XqbMD*h<++2ec+wZ(*U_K8(0>c0Y?6`BRearpNRj9BNcf#CS`=# zB+E3WR#c7&>{w`AaQ&%4E(Xl{Y53FPr+zSzoEtb!)-Tm)SYYt&AbIkBst0{k(oDit z%4mWJy_bZmek_wYU4Ifw>U$QLBxTB60xW5j*-zY8*;nPGN|zM1Uaro1>z{TSxd}y1 zm0Iz$UmHJgB?hILK9-8_M^3UdzRes~G}ElTU%(hTAF3MC9>N-u7#e2IU=CnLVy0jo zS7Rz8pV68@pAnrw;-%wdZ}4v5YhXC|>JsbOeur}fcSVP#5MvnALAp#@mob@Pm*J6N zn}Mg}%&J?7St(r^21T@ubxpihIl31ri7i!ZSF9Wp(Nmj~=l=*RIX)$QAdTWJwI-d5 zKAgC0_FV9^^-Q{Z=cDup|7iEfk8Fi(gp7iPj0qvlAf+ecBN63IK5| zX8y(c!GYDM@&Za>?KKPGo#2h&6f`>@NH#h!ZJnzhzl=(6Az7_hwi){}D*UH?%=<_8 z){TR#VAH!(!fV3!@7Q#_fAQ4eYh^b)bjyx250=eXxn}LOrnx8_7FDQM&{mRFgz(v9 zqGoRLiR+p!f)}M1iCoKECtOEexxd)j(ZG0MF&()gtB@(*!LCW8%x-m=k%`{gdB=fI zf0+K3_U*USMLPX(%Df1SDjnANUS8#{i9HuowP}ZLC)`BXgyiM~vps&K*Jqy|UOtSU>+!t0Dm`rL=vo}TkB4znDdb@0QZjqXiVm&2y zmvOJoKgwgt+cmB*88R_5t~41oG2g7%eAPSJyV$4MH_jmNcKU6*g0n(}(ihotMWOWi z4DugK3F5L5;Ffsigp6cpPElHFCf|>$O#NiGk(v>KAGN<>Yy9Rk>15nqi1Hs>4LRgk ztd(ZJHY&KNFW`^1G?rQJ4=-2RP~raR2$z+Q_IQzRs13Lz0ZA^o%>R=%hc`872NUf6y4b-ww1O} ziZH#pHoc&tpsdccr%A!DeA6!D5BlRiQTH9)hoS6o^RZvN)^65zB$~q9Wai>t#UaIt zkYZC2iAMVJ+zZ^EEix=9rRE&}_^pI5hUcYm`{l`Fvl`mziaHwnot}aL#o(sXU8pzH z^HF!lo@FY8eV?7hJlRagEXJIDOmKYJuVH=W^6+wQ_(G~P>RBHqeK>k6_V0=K3#xXS z@33Fno%#OzbT@|8%=Q!AOKtBb>h13H&u22}amAvJqFCOqo`mau)QNv7y~}$ngq8Qt zMa(46%shj{-^D}TlS=6W*y)W4__G2CVN(^N$> z8gt;En>~MSOs)}FoH?Zjv6-Q-nApxmD_a#K2RC-wzcMe$es{dVkJ@FSJde1jV3wb^a3{_knB zZoEY}KMF%Dg$G_doQW?2bh1u@h(G!EeAN9r8Lsl#o^(bib>aQzK=r{lTIy?$b&?iK zI`FI2ujOe9PE2Ucu*=*j;A`IZ%qA2?ozlE?I#tu(Shx7vl^w3Be-k+oLDT&;Rl-~tfJkhp;~ z{d_u($xi^Cplg0ur(x+E7qH-GtqMWA-$3vbeX0X zo%R3Ct1=FBI0Z-L?3HwIH^M2|~rRGh!*}QDEO#s^}5WW3$?3Vc=CYmy*NswL*R5;m+h1TC5i(Ev+9BK8d0v z^d>|%vu#N1rkn@g7Ud738iqe57z0n-#v1N@K?p9ZYQDVhdw&fu1GY2s3QBLSf%l$8iLK~ck~N=|Mo?X%ueU% zeBlDVy=8LutJN;%!E>OfZFdzvk%+po7VA;Zlaws&$KjhqQ)Tf-f9neOF=XSl*L%Ad z=3AuTWwRcGke+A`saq(T*Rp%3D`#K#W<)sSEBXd@f5vZ5=pYxIe{e+m7lX8)vf}d! z(I=e^k^E=V?~8AdKy7eIv<=l+19LG~)+q2SE>wz-kZ*uM7H~i5TpgFIS}O@D{0o^Y z8T;>3RUK5~7j^%?KC+-HTsrh&`>^^zT##o=77}0x63lK`;K_#Xf>vUk3g5mwICyZO z7H7SwWP6&U2Bzl`-y8)5P41#MmJ4S`yx0tar&Ls91z+ok=c^ZrFv{Y@R1MmTSQ)Sa z(^W__NX!TXj!y!X4Wj16B>^tu;1te}7+Uw(^~wejzOWr9q4gn5TuK+?KwN6k`hVx0 z&xN*`vr5*hm-;lkm?TT)2U!)<`dhf;Ug?*MQu>)RTfC1J6Y8=6q>pA2v6JF7N4W=z z=27=Wtf*4du>NJMQgbN8X6jnc(y!_~XFGr6-|T zASqMb*hW!VL~l7tdTv`VR>M2YOenAXaiEpOOo9@9C=l%g{Y05SA_Il{TdMR_(*V3t zEv+mn4X5Qw{!q|?{FC{#N&}Py@`Q8dI~JiX^NEr4>^7uLY}^mu%dUTY0H>VV*n5aXpJTyfoivyW9Q$uxRPn+?UJE$c^Ch?~7N!Iq*C*~2=6C^oQ1 zg5w1KNL!ArhTjBYfigfzv}KyxU^0>)`MD3Ti=<~I!D9ARyvHK7I!D&DleDolDx?<} z;E}S?R^u(!aI}1Chi31>WQwmNe>vr}8E7X%!=IEk77~ z*5gfLe^87|q(|cGS&rF{Let@ti3V;lL3-1!Jg$xM`_-Dm<_caI!3hyajd4{bc?=*z z0S-OWe51tOdVd1nB)*J<2U5XvZpoi%<3L`3m;%PjsB-|@;F)F-L1FOK)Yh2o?CVX` zulI3+V!#r_wgu|IC}(jUp4VSFt^^mQ=IB8qCjtqByER2*yE>qON1!)kCW(`iX|g>BB%0`nLn0`mV?wJYtFe< z#Cy}d*>#KabKCi9I06_e9fM=Q-2iO|@zXqQdPdZ96wa1%2n#K%@tWyPdw2uMj&V8X z!|P)wqzC`5tmu1~o^IKii@NLSU!@-?C-HtHRk3#FNv3-B&`K~lZ9@xku*Rlg6MBRG z@lgtex;hdAhY=3CxX1$cAm}d(V(;|XS`3Q6{-Ek&qU(XK0cm1Ag+%^7P|K_DH>Az@ znAwHQ0cGTi4LvX0W;xMr^gPP3fvchXt+X9?G+(Yst|(L}yFF`}JJ|LFx~29cj5EGh_>C%}_q zZL6nW{L0B}-Y@;py#G;Jx@gg7b7(j~*`xwz|24q9Fk)N$G1$}aF2w5*+V95_mNA$- zq0@Qc=f}L5;a3fvla{OnK-fNheoXRKFCu@x%y6t*``YC_gMmtLhSJd?ZQc#Xe7N&S z&BQD{pEz_j7mYVi;%In+tG8_Y3gj!qZXK{m=64ZA3nI3XME+w)J1N*LO%_78n&0TW zV217g30y8pk&==k^V@4W95bRz`YR~9@$z+h+S>W=2#oUC2S*Z#n1LGr`5|{%a91gp ziz*aF&oboPO%(sCyp@@Th|OJhV0xa6d$StRMw~Yf6dDWktudHC>2c37FqW#LWvPuB(Ji>cZnN}|$ zgzu$D|6%&}(t^dm8|1m^LnGqIldQR<@{|&C`{!WXqE4?nNKR}_L=Ki?@U;0fz~o6v;HGzpxK^^!d`Iy_ zcwhGJo3M7pg#M`K0BKX;oo6ED%R3h&D(Z&3Eo=(d$xW02=X5wDE+${zw47xL(>^^E z+9L#N0KNJt9d2P-K?vCI@?XEcQDpKxn^O7DqiJ0GyJgm=Ra_#4uroq8uW4 z{bPz5pxD_N&JU4g*Jhik9KY0Z(FjHjVBxJPNnqi(P-liEoX>H->t4d*k>MLJD^QMx zWPA>{I7E}oWRq!_o(1&k_PCY^woKg7{zC?gqml=x9Inz-ZV}Hgm@J=FJfIix3Z%i# z2EDwvprYs)RHn_71muq{)=pd@VuDaaMxy0$X4ZJ2914w0^irv};kJu@IKn$(f?TbfPa^itcU3~H$WY z@|pV_ly=??4u7u>A6~X=GI-It%N|48$RUFc3~z;_C@`8-eZvPK`k|VM9l&wu#JByc z+s^FF2>4J!?GUVHYHGTMTKd-uT}fU(Z3f~?!v$!}1ZJlLd=47yqe7*QeBzx)1cWRhBlG5K$tRad$LeYO0l@kuqzO$ zs=!w)obd>teGwudp0EYV-4mA9ZP-UDdn9>F0vj$oWvVm`dG-34k2>=ch`$r|7_i-f zr#t-IpMw@=AD+z{`D5Z*Dv%@*0(?Zb7)#akFpgWl94O#K^K^^2y4CF3YeI zToT%Lm5ag&K)%4@WI&QWv*sEaso!g*C9Mo=RD_I5=)!076(BOB#)G=ZYwz&OMLGM8 z;b~}Cje)m@C3FFV`K<1oT?HpaZHGN^klU2I@4kqkq&WM;K{3(Mxv5`2Mf2T`v*f9_ z#D;$J+G+ongIIlsxs-pM|J4^8@Rm4*@W8>4dKR>fLZ(2GxL0v)Zb}9 za#S|%?m)#yBTI)&MuH}xKu4W-WTcwd`8?E%*y7PEHaax)xSgc*xF=R9G)>5^FTCg4 zRyp{f6A?~q^A!=37Yh}~_KJRgoYv^YL&!xA&3(6fc#s|u5I@KXcpFN}(SW@eh=lRw zaJKS23u>Soey=dV5jwJK!vm4)6h}`O#i15NU1hEUmV9C{YJei|-u5BHf zuMrgka8+bE=fQErR-~x|78owU$@YI1Nd@9Xw#!B9e*J2X=B4?J04x@qTZHE*qnoMK zH1D-y$hvpKDkE5bvRFgo-G40GaYhi6~Uv1MW_%Pk6omz=oSuSGcq#?(w z;e(4~NfH!O4;;y9LNfE)%q}Wd7O3W|3Z>fbVjTsr$jR5lHU(0cya?&6&@Hd&RJO%` za2yf8%f=Pt&c}WLN7aX&LonA(3gGByUuy}o*#PzxMhj@SyBfZSHb&u=i) zZ@F;?@7y?W7=eMULg%92^t^0*ZoJf|cO5A#W7LdnqmfcF*#?tu55G$M=iH6Ft5RSmbs(PBg`KR4nhBcdU2wY^xo%;?-nsZoV4d1X~lekxWL%# z!5UNF)THTp{qSo~e6_P{WB9}NeRs3d30$%1?Ewj_BxNMb%_)0Tor_App;~v)hEFLu zIr+!#EU>*5umA$E03#9J%MqWwOP}3jo;EO^SCa%4=g;DaZFIHExrtiJ4_X^4Fty;?oGeU?misOX zdLsZt4i@M^F`ol+Q|Xf#@V>M>tlR>_FHoI=lgTZB&?T>hbDlAs*vgV-8t1cwW~=Xw zxxw9Wg$$Szm`c-anE%zVq%h(C^=?_p6?d3Fgc;H1sR8Oq!!bP>{%wZAKc|ZE zR-*s${nLi#S@uU@~gM!PM6wi^o5k&%AUp;F$4oSA+os|LFB~nyDViqUwSIrK1xJ zoCF$N+rYZBS}&<1#J5D*R)vLI*bH$^#nr4fs@o_)r%Oagzda|6HqwEm_db2OBYJV(f z^PKw(r}Ft~Uwx2Ub8DNRr$qjX#vCpVP#1H#YG zB_b^&V(kj2F%^TMZj(BDNCh+bI#G=Q0Re%--`R-(mt<*mh(p6giJU2_4rhV>pc9O* z^|@jO)tG#I7@$3Xo0j<5+_aoh|H-7$7ECK!U3tk>HWPdtVil`@ZTqbR?)RS%3@N+A zkCKBgrz2fo*X^{!BZE_W1JN=mDU1N1RjcB|_=(?9_4DoF-w!3D(ijtbqM~+!9_L?4 zK<~7FeT~1b0itA%`O7lE%`E%B59U6I_FZ{Sd&QixYR0>F~K>Uvl_|bqgl~y7ywb7iI(5S30&c`G0C%X=`hH z6#V+dWh4Wp)4k}84s)^g5t6m|3iS%KZe|d+u_i!YdNk! z)SbBLS1)|gl6}k%6|cCPeiX5qkaeja%-y-T zuRT^;88G%LwWO^bobGp59quX>T9+^t(m=O-=DkG?iU1p|1M$9H8yEnO{r>$Mx1kdN zIef^OkWrVo4AkFnp_$Zxhecew`L--Z2^T+`Ta^6ILN!#!%#6NsS2CFklg}s8l@qR8 zp%`!z?^4@ML1W^8I17D|e_fh*dulg!(I&e?d*IcbNMZ}X1%8c6otf%uSXlTZc94R> zhThen!&JmtFJclT^SBC6>~2T%z~BxClicc8)-Xeu8=K4s+4Q$7MjR5XAO$Mi4iS`Y zg?xa2*CQSaVrWjm({Vr?BVtsKlaRnMU(dR5U&6V>QvkU9$wQYJH`fPP+oaEodEQ7k zAcg-}nD&DfMot)T_R)hBGCy~$vvw;;0gj(gZbfN#wC?F)*rn2MTv;yKa)OVGCT%>c z?q;^?NKvvrA}_6%MvY-G`rZJ=KP zbjOWuLl6(gc5`zx6AV<{{q{BuB85nE-54o9eNV6c$*5dXR@ z7Wu%KGR8MGp6z3@0Y-TGgc3u9jkp(;vux1mot&K1f6=7UWFW&-zy$Y!)}IiZaLrLq zWG(xx*)|OSdq3QCsgH{1S;zBv%L%*ykK>eTdP2fJUuK=Y`$4tuhC7$om`)ohx?pnpM0$(SD!aDlt21 zmScYeJqG71ylR-3m}p1BAbe{>z=ES9fZ5ms-c`ovJyk7SSZLG~rrbrQq&9tnBbnKb zy|}k$kqxMieuw8(X>BbhhRi}Z;{vhGnNi6nt8VY3P%Qqq{uXL(Zm*K#aL0r!(TaGd*Va{^pQBwwf4aVLA+^YMqS zQrL4`{1E&0Tqjg>%h6z0yI4}F-!KYOf>rpv{|X~jw*&1FMr5P>cR7$@1Mhgmd1kUpZ5^`F@V3%OOABHEWoW&HH_w@mx!^u{ygX zi7g)9#fXW??3zi%j*H9a_`}WSZK|e$9`Ui|kFkr?3m=AyjanI?6oxPS%N!WSOGsGHgpIwQRrR}mps;_kE2uZQzy7m+xbrT@BipYrEazzr zY;>wt((kkUaArh>`aP_C_RU$&aUn1K{j0H_En!VChvE{86Amj za6@%$TqT5--%L2;*(FQM7Y(9)AD-K9yjk|^VD0vvvL<~PGWz1N{iW~shn;o@Y$u^{ zU37GfWmMm1`xW1o5@V;)zX=9U-Ll&QbLG$X)%=p&xP%8Dihd4~?!}u8mR{YJzg9)Q zZJz@}nfuy z7ULbp>#kP%Q6zjIb6!Ch*x}C1dM~?nevPRL0aDTG?!uIEN=izfG&MCBZf=@Q*RKvu zo}XGd_&D7WTrcy`!_Mw+DBclA9e6}(CbtY9-{76~oaGQytTx+ft&E>+u57mSve;2Y zz&wDA6y#5@Ym?P#GhZ#d?S^`NM4NgWGELB@CPR}FI%#IVE z`HV_k2nm_VM-dV|uf*WYrNqMuVxlp%cg%NhLHqhma*tG7ta^=I%eRV)l_|xFyB>1) z><~?^MIYOt-LvNE%xXQd8bqb?SdT9|$uX@ns2!l=zUfuGHaK$e%srXR`LsmqH(bQ| zIdnsHqIlIvlQ6ECeCym2SB?Ee8OY=Ji#npL(h6@EwIh4@-to;dEjGPYwJm2Mj1jXs z`?HPSpmL4M1MI67j0*;z#m4Ap^1FsX=lw{!!#ljI?~f)#M47_b(e3?|EG|c@t3FP{ zsk%nVwxcjp?Qh3bHAKd^%0Ap2P%*@ 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 literal 0 HcmV?d00001 diff --git a/modules/calib3d/doc/pics/pinhole_homogeneous_transformation.png b/modules/calib3d/doc/pics/pinhole_homogeneous_transformation.png deleted file mode 100644 index f98e4ba21746d3a1e3e3ee9674e77044937bbb0b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 79039 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�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 diff --git a/modules/calib3d/doc/pics/robot-world_hand-eye_figure.png b/modules/calib3d/doc/pics/robot-world_hand-eye_figure.png index 867bc81c7332365ed1699848aea5cb3669651665..26f5eca076bdcf6453dcd101ff77396d509de71c 100644 GIT binary patch literal 39694 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%0AgLkJkp9O%iUXUUzA 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�D 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 Date: Mon, 9 Mar 2026 14:20:43 +0800 Subject: [PATCH 20/32] core: use void* in countNonZero signature per team review --- modules/core/src/count_non_zero.simd.hpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/modules/core/src/count_non_zero.simd.hpp b/modules/core/src/count_non_zero.simd.hpp index 26af0a8d71..c93f31cce6 100644 --- a/modules/core/src/count_non_zero.simd.hpp +++ b/modules/core/src/count_non_zero.simd.hpp @@ -6,7 +6,7 @@ namespace cv { -typedef int (*CountNonZeroFunc)(const uchar*, int); +typedef int (*CountNonZeroFunc)(const void*, int); CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN @@ -29,8 +29,9 @@ static int countNonZero_(const T* src, int len ) return nz; } -static int countNonZero8u( const uchar* src, int len ) +static int countNonZero8u( const void* src_ptr, int len ) { + const uchar* src = static_cast(src_ptr); int i=0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -66,9 +67,9 @@ static int countNonZero8u( const uchar* src, int len ) return nz; } -static int countNonZero16u( const uchar* src_ptr, int len ) +static int countNonZero16u( const void* src_ptr, int len ) { - const ushort* src = reinterpret_cast(src_ptr); + const ushort* src = static_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -102,9 +103,9 @@ static int countNonZero16u( const uchar* src_ptr, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero32s( const uchar* src_ptr, int len ) +static int countNonZero32s( const void* src_ptr, int len ) { - const int* src = reinterpret_cast(src_ptr); + const int* src = static_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -138,9 +139,9 @@ static int countNonZero32s( const uchar* src_ptr, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero32f( const uchar* src_ptr, int len ) +static int countNonZero32f( const void* src_ptr, int len ) { - const float* src = reinterpret_cast(src_ptr); + const float* src = static_cast(src_ptr); int i = 0, nz = 0; #if (CV_SIMD || CV_SIMD_SCALABLE) int len0 = len & -VTraits::vlanes(); @@ -174,9 +175,9 @@ static int countNonZero32f( const uchar* src_ptr, int len ) return nz + countNonZero_(src + i, len - i); } -static int countNonZero64f( const uchar* src_ptr, int len ) +static int countNonZero64f( const void* src_ptr, int len ) { - const double* src = reinterpret_cast(src_ptr); + const double* src = static_cast(src_ptr); int nz = 0, i = 0; #if (CV_SIMD_64F || CV_SIMD_SCALABLE_64F) v_int64 sum1 = vx_setzero_s64(); From 918244763d52a779fcc53dcd3a0abdad3eb5bdf0 Mon Sep 17 00:00:00 2001 From: Souriya Trinh Date: Tue, 10 Mar 2026 12:15:50 +0100 Subject: [PATCH 21/32] Create Charuco objects only if the selected pattern is a Charuco board. Otherwise it gives the following error: opencv/modules/objdetect/src/aruco/aruco_board.cpp:543: error: (-215:Assertion failed) size.width > 1 && size.height > 1 && markerLength > 0 && squareLength > markerLength in function 'CharucoBoard' --- samples/cpp/calibration.cpp | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/samples/cpp/calibration.cpp b/samples/cpp/calibration.cpp index ac80a06b59..d5df35d64a 100644 --- a/samples/cpp/calibration.cpp +++ b/samples/cpp/calibration.cpp @@ -540,9 +540,14 @@ int main( int argc, char** argv ) dictionary.readDictionary(fn); } - cv::aruco::CharucoBoard ch_board(boardSize, squareSize, markerSize, dictionary); + cv::Ptr ch_board; std::vector markerIds; - cv::aruco::CharucoDetector ch_detector(ch_board); + cv::Ptr ch_detector; + if (pattern == CHARUCOBOARD) { + ch_board = cv::makePtr(boardSize, squareSize, markerSize, dictionary); + ch_detector = cv::makePtr(cv::aruco::CharucoDetector(*ch_board)); + } + if( !inputFilename.empty() ) { @@ -563,7 +568,7 @@ int main( int argc, char** argv ) if( capture.isOpened() ) printf( "%s", liveCaptureHelp ); - namedWindow( "Image View", 1 ); + namedWindow( "Image View", cv::WINDOW_AUTOSIZE ); for(i = 0;;i++) { @@ -612,7 +617,7 @@ int main( int argc, char** argv ) break; case CHARUCOBOARD: { - ch_detector.detectBoard(view, pointbuf, markerIds); + ch_detector->detectBoard(view, pointbuf, markerIds); found = pointbuf.size() == (size_t)(boardSize.width-1)*(boardSize.height-1); break; } From c3457f99f34cacd89db2c7a187b41abaa281a734 Mon Sep 17 00:00:00 2001 From: Matt Van Horn Date: Tue, 10 Mar 2026 22:55:36 -0700 Subject: [PATCH 22/32] Merge pull request #28621 from mvanhorn:osc/28528-fix-houghcircles-return-type imgproc: fix HoughCircles Python return type to allow None #28621 ### 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 ### Description Fixes https://github.com/opencv/opencv/issues/28528 `HoughCircles` returns `None` when no circles are found, but the auto-generated Python type stub declares the return type as `MatLike` without `None`. This causes type checkers (mypy/pyright) to miss potential `None` dereferences. **Fix:** Add `HoughCircles` to `NODES_TO_REFINE` in `api_refinement.py` using the existing `make_optional_none_return` helper - the same pattern already used for `imread` and `imdecode`. This contribution was developed with AI assistance (Claude Code). --- modules/python/src2/typing_stubs_generation/api_refinement.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/modules/python/src2/typing_stubs_generation/api_refinement.py b/modules/python/src2/typing_stubs_generation/api_refinement.py index f92c5c8ce1..14d64e0cb8 100644 --- a/modules/python/src2/typing_stubs_generation/api_refinement.py +++ b/modules/python/src2/typing_stubs_generation/api_refinement.py @@ -457,6 +457,9 @@ NODES_TO_REFINE = { SymbolName(("cv", "fisheye"), (), "initUndistortRectifyMap"): make_optional_arg("D"), SymbolName(("cv", ), (), "imread"): make_optional_none_return, SymbolName(("cv", ), (), "imdecode"): make_optional_none_return, + SymbolName(("cv", ), (), "HoughCircles"): make_optional_none_return, + SymbolName(("cv", ), (), "HoughLines"): make_optional_none_return, + SymbolName(("cv", ), (), "HoughLinesP"): make_optional_none_return, # Fix for issue #28534: inRange should accept Scalar for lowerb and upperb SymbolName(("cv", ), (), "inRange"): make_matlike_or_scalar_arg("lowerb", "upperb"), } From fb6f5cc28282c12fcb66fd3bca9798c0fb0d9425 Mon Sep 17 00:00:00 2001 From: Prasad Ayush Kumar <22bcs191@iiitdmj.ac.in> Date: Wed, 11 Mar 2026 13:12:09 +0530 Subject: [PATCH 23/32] DNN/ONNX: Preserve axis attribute in GatherCastSubgraph fusion --- .../dnn/src/onnx/onnx_graph_simplifier.cpp | 21 ++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/modules/dnn/src/onnx/onnx_graph_simplifier.cpp b/modules/dnn/src/onnx/onnx_graph_simplifier.cpp index 4b857ebc16..b4284af7b1 100644 --- a/modules/dnn/src/onnx/onnx_graph_simplifier.cpp +++ b/modules/dnn/src/onnx/onnx_graph_simplifier.cpp @@ -1278,14 +1278,33 @@ public: } } } + // extract axis from original Gather node + axis = 0; + opencv_onnx::NodeProto* origGatherNode = + inpNode.dynamicCast()->node; + for (int i = 0; i < origGatherNode->attribute_size(); i++) { + opencv_onnx::AttributeProto attr = origGatherNode->attribute(i); + if (attr.name() == "axis") + axis = attr.i(); + } } } } return retVal; } + virtual void finalize(const Ptr& net, + const Ptr& fusedNode, + std::vector >& /*inputs*/) CV_OVERRIDE + { + opencv_onnx::NodeProto* node = fusedNode.dynamicCast()->node; + opencv_onnx::AttributeProto* new_attr = node->add_attribute(); + new_attr->set_name("axis"); + new_attr->set_i(axis); + } + private: - int cast, gather; + int cast, gather, axis; }; /* Constant folding shape for Expand. From a02fcb360d20e14180f220bc4edc5a309f5a38cb Mon Sep 17 00:00:00 2001 From: Souriya Trinh Date: Wed, 11 Mar 2026 08:56:46 +0100 Subject: [PATCH 24/32] By default, exif orientation is ignored when reading images sequence for the calibration exe. Add an option to apply exif image orientation. --- samples/cpp/calibration.cpp | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/samples/cpp/calibration.cpp b/samples/cpp/calibration.cpp index d5df35d64a..99cb1a547b 100644 --- a/samples/cpp/calibration.cpp +++ b/samples/cpp/calibration.cpp @@ -90,6 +90,7 @@ static void help(char** argv) " # the calibration grid. If this parameter is specified, a more\n" " # accurate calibration method will be used which may be better\n" " # with inaccurate, roughly planar target.\n" + " [-imread-apply-exif-rot] # use this flag to apply the exif orientation when reading images from list\n" " [input_data] # input data, one of the following:\n" " # - text file with a list of the images of the board\n" " # the text file can be generated with imagelist_creator\n" @@ -408,6 +409,7 @@ int main( int argc, char** argv ) "{oo||}{ws|11|}{dt||}" "{fx||}{fy||}{cx||}{cy||}" "{imshow-scale|1|}{enable-k3|0|}" + "{imread-apply-exif-rot||}" "{@input_data|0|}"); if (parser.has("help")) { @@ -497,11 +499,16 @@ int main( int argc, char** argv ) } int viewScaleFactor = parser.get("imshow-scale"); bool useK3 = parser.get("enable-k3"); - std::cout << "Use K3 distortion coefficient? " << useK3 << std::endl; + std::cout << "Use K3 distortion coefficient? " << (useK3 ? "yes" : "no") << std::endl; if (!useK3) { flags |= CALIB_FIX_K3; } + int imread_flag = IMREAD_COLOR; + if (!parser.has("imread-apply-exif-rot")) + { + imread_flag |= IMREAD_IGNORE_ORIENTATION; + } float grid_width = squareSize *(pattern != CHARUCOBOARD ? (boardSize.width - 1): (boardSize.width - 2) ); bool release_object = false; @@ -529,15 +536,17 @@ int main( int argc, char** argv ) return fprintf( stderr, "Invalid board height\n" ), -1; cv::aruco::Dictionary dictionary; - if (dictFilename == "None") { - std::cout << "Using predefined dictionary with id: " << arucoDict << std::endl; - dictionary = aruco::getPredefinedDictionary(arucoDict); - } - else { - std::cout << "Using custom dictionary from file: " << dictFilename << std::endl; - cv::FileStorage dict_file(dictFilename, cv::FileStorage::Mode::READ); - cv::FileNode fn(dict_file.root()); - dictionary.readDictionary(fn); + if (pattern == CHARUCOBOARD) { + if (dictFilename == "None") { + std::cout << "Using predefined dictionary with id: " << arucoDict << std::endl; + dictionary = aruco::getPredefinedDictionary(arucoDict); + } + else { + std::cout << "Using custom dictionary from file: " << dictFilename << std::endl; + cv::FileStorage dict_file(dictFilename, cv::FileStorage::Mode::READ); + cv::FileNode fn(dict_file.root()); + dictionary.readDictionary(fn); + } } cv::Ptr ch_board; @@ -582,7 +591,7 @@ int main( int argc, char** argv ) view0.copyTo(view); } else if( i < (int)imageList.size() ) - view = imread(imageList[i], IMREAD_COLOR); + view = imread(imageList[i], imread_flag); if(view.empty()) { @@ -718,7 +727,7 @@ int main( int argc, char** argv ) for( i = 0; i < (int)imageList.size(); i++ ) { - view = imread(imageList[i], IMREAD_COLOR); + view = imread(imageList[i], imread_flag); if(view.empty()) continue; remap(view, rview, map1, map2, INTER_LINEAR); From 8e1fa1bbdce62e2454522bdc981429cc27b57461 Mon Sep 17 00:00:00 2001 From: Matt Van Horn Date: Thu, 12 Mar 2026 00:37:24 -0700 Subject: [PATCH 25/32] Merge pull request #28620 from mvanhorn:osc/28619-fix-yaml-parsekey-empty-key-oob core: fix heap-buffer-overflow in YAML parseKey for empty keys #28620 ### 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 ### Description Fixes https://github.com/opencv/opencv/issues/28619 Moves the "empty key" check before the backward do-while scan in `YAMLParser::parseKey()`. **Problem:** When parsing a YAML mapping with an empty key (e.g. `: 10` at column 0), `endptr == ptr` after the forward scan finds `:`. The do-while loop `do c = *--endptr; while(c == ' ')` always executes at least once, so it decrements `endptr` to `ptr-1` and reads one byte before the heap allocation (ASan: heap-buffer-overflow READ of size 1). **Fix:** Check `endptr == ptr` before entering the backward loop. If the key is empty, raise `CV_PARSE_ERROR_CPP("An empty key")` immediately without the OOB read. This contribution was developed with AI assistance (Claude Code). --- modules/core/src/persistence_yml.cpp | 5 +++-- modules/core/test/test_io.cpp | 15 +++++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/modules/core/src/persistence_yml.cpp b/modules/core/src/persistence_yml.cpp index 009ab7d8b7..d926fd0b2e 100644 --- a/modules/core/src/persistence_yml.cpp +++ b/modules/core/src/persistence_yml.cpp @@ -432,12 +432,13 @@ public: CV_PARSE_ERROR_CPP( "Missing \':\'" ); saveptr = endptr + 1; + if( endptr == ptr ) + CV_PARSE_ERROR_CPP( "An empty key" ); + do c = *--endptr; while( c == ' ' ); ++endptr; - if( endptr == ptr ) - CV_PARSE_ERROR_CPP( "An empty key" ); value_placeholder = fs->addNode(map_node, std::string(ptr, endptr - ptr), FileNode::NONE); ptr = saveptr; diff --git a/modules/core/test/test_io.cpp b/modules/core/test/test_io.cpp index 7e2a9d52d4..a6d44a3316 100644 --- a/modules/core/test/test_io.cpp +++ b/modules/core/test/test_io.cpp @@ -1673,6 +1673,21 @@ TEST(Core_InputOutput, FileStorage_free_file_after_exception) ASSERT_EQ(0, std::remove(fileName.c_str())); } +TEST(Core_InputOutput, FileStorage_YAML_empty_key) +{ + const std::string fileName = cv::tempfile("FileStorage_YAML_empty_key_test.yml"); + const std::string content = "%YAML:1.0\n---\nkey1: value1\n: 10\n"; + + std::fstream testFile; + testFile.open(fileName.c_str(), std::fstream::out); + if(!testFile.is_open()) FAIL(); + testFile << content; + testFile.close(); + + EXPECT_THROW(FileStorage(fileName, FileStorage::READ), cv::Exception); + ASSERT_EQ(0, std::remove(fileName.c_str())); +} + TEST(Core_InputOutput, FileStorage_write_to_sequence) { const std::vector formatExts = { ".yml", ".json", ".xml" }; From 84300d5025918d53d6fd06008a1eae9b8959ab0b Mon Sep 17 00:00:00 2001 From: rajmahadev422 Date: Fri, 13 Mar 2026 13:08:39 +0530 Subject: [PATCH 26/32] Merge pull request #28618 from rajmahadev422:vscode_opencv ### 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 - [ ] 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 ## This tutorial describe how to build opencv from source in windows using VSCode and MSYS2 --- .../table_of_content_introduction.markdown | 1 + .../window_install_opencv.markdown | 270 ++++++++++++++++++ 2 files changed, 271 insertions(+) create mode 100644 doc/tutorials/introduction/windows_msys2_vscode/window_install_opencv.markdown diff --git a/doc/tutorials/introduction/table_of_content_introduction.markdown b/doc/tutorials/introduction/table_of_content_introduction.markdown index 2f8303ad6e..d67dd20cbc 100644 --- a/doc/tutorials/introduction/table_of_content_introduction.markdown +++ b/doc/tutorials/introduction/table_of_content_introduction.markdown @@ -18,6 +18,7 @@ Introduction to OpenCV {#tutorial_table_of_content_introduction} - @subpage tutorial_windows_install - @subpage tutorial_windows_visual_studio_opencv - @subpage tutorial_windows_visual_studio_image_watch +- @subpage tutorial_windows_msys2_vscode ##### Java & Android - @subpage tutorial_java_dev_intro diff --git a/doc/tutorials/introduction/windows_msys2_vscode/window_install_opencv.markdown b/doc/tutorials/introduction/windows_msys2_vscode/window_install_opencv.markdown new file mode 100644 index 0000000000..a1c3bb7298 --- /dev/null +++ b/doc/tutorials/introduction/windows_msys2_vscode/window_install_opencv.markdown @@ -0,0 +1,270 @@ +Building OpenCV on Windows from Source Code using MSYS2 UCRT64 and VS Code (C++) {#tutorial_windows_msys2_vscode} +===================================================================== + +| | | +| -: | :- | +| Original author | Mahadev Kumar | +| Compatibility | OpenCV >= 4.x | + +@tableofcontents + +@note This tutorial was tested on Windows >= 7 using the MSYS2 UCRT64 environment. +@note The OpenCV team does not maintain MSYS/Cygwin configuration and does not regularly test it with continuous integration. + +--- + +## Introduction {#tutorial_windows_msys2_install_intro} + +This tutorial explains how to build OpenCV from source on Windows using the **MSYS2 UCRT64 toolchain** and use it inside **Visual Studio Code with C++**. + +The build configuration uses: + +- **MSYS2 (UCRT64 shell)** +- **GCC (UCRT toolchain)** +- **CMake** +- **mingw32-make** +- **VS Code** + +This method produces **native Windows binaries linked against the Universal C Runtime (UCRT)**. + +--- + +## Prerequisites {#tutorial_windows_install_msys2_prerequisites} + +Install the following software before proceeding: + +- [MSYS2](https://www.msys2.org) +- [Git](https://git-scm.com/install) +- [Visual Studio Code](https://code.visualstudio.com) + +After installing MSYS2, always open the: + +**MSYS2 UCRT64 Terminal** + +@note Do not use the `MSYS`, `MinGW64`, or `CLANG64` shells for this build. + +--- + +## Step 1: Update MSYS2 {#tutorial_windows_msys2_install_update} + +Open the **MSYS2 UCRT64** terminal and update the system. + +@code{.bash} +pacman -Syu +@endcode + +Restart the terminal if prompted. + +--- + +## Step 2: Install Required Packages {#tutorial_windows_msys2_install_packages} + +Install the required compiler and build tools. + +@code{.bash} +pacman -S mingw-w64-ucrt-x86_64-gcc \ + mingw-w64-ucrt-x86_64-cmake \ + mingw-w64-ucrt-x86_64-make +@endcode + +Verify installation: + +@code{.bash} +gcc --version +cmake --version +mingw32-make --version +@endcode + +@note **Add the following directory to your `Windows PATH`:** +@code{.bash} +C:\msys64\ucrt64\bin +@endcode + +--- + +## Step 3: Clone OpenCV Source Code {#tutorial_windows_msys2_install_clone} + +Clone `OpenCV` and optional `contrib modules`. + +@code{.bash} +git clone https://github.com/opencv/opencv.git +git clone https://github.com/opencv/opencv_contrib.git +@endcode + +--- + +## Step 4: Create Build Directory {#tutorial_windows_msys2_install_build_dir} + +@code{.bash} +cd opencv +mkdir build +cd build +@endcode + +--- + +## Step 5: Configure the Build with CMake {#tutorial_windows_msys2_install_configure} + +Run CMake using the **MinGW Makefiles generator**. + +@code{.bash} +cmake -G "MinGW Makefiles" ../ +@endcode + +@note If you do not want to use **opencv_contrib**, remove the `OPENCV_EXTRA_MODULES_PATH` option. + +--- + +## Step 6: Build OpenCV {#tutorial_windows_msys2_install_build} + +Compile OpenCV. + +@code{.bash} +mingw32-make -j6 +@endcode + +@note If the build fails due to memory limitations, reduce the job count. + +Example: + +@code{.bash} +mingw32-make -j4 +@endcode + +--- + +## Step 7: Install OpenCV {#tutorial_windows_msys2_install_install} + +Install the compiled libraries. + +@code{.bash} +mingw32-make install +@endcode + +After installation, OpenCV will be located in: +`opencv/build/install` + +Add the following directory to your **Windows PATH**: +@code{.bash} +C:\path\to\opencv\build\install\x64\mingw\bin +@endcode + +--- + +## Step 8: Verify with a C++ Example {#tutorial_windows_msys2_install_verify} + +- Create a folder outside the OpenCV source directory. +Example: `first-project` +- Inside the folder create **main.cpp** + +@code{.cpp} +#include +#include + +int main() +{ + std::cout << "OpenCV Version: " << CV_VERSION << std::endl; + + cv::Mat img = cv::Mat::zeros(400, 400, CV_8UC3); + + cv::imshow("OpenCV Test", img); + cv::waitKey(0); + + return 0; +} +@endcode + +- Create **CMakeLists.txt** + +@code{.cmake} +cmake_minimum_required(VERSION 3.10) + +project(OpenCVApp) + +set(OpenCV_DIR "C:/path/to/opencv/build/install/lib/cmake/opencv4") + +find_package(OpenCV REQUIRED) + +add_executable(app main.cpp) + +target_link_libraries(app ${OpenCV_LIBS}) +@endcode + +- Build the project. + +@code{.bash} +mkdir build && cd build +cmake -G "MinGW Makefiles" .. +mingw32-make +@endcode + +- Run the program. + +@code{.bash} +./app.exe +@endcode + +@note If everything is configured correctly, a window should appear displaying a blank image. + +--- + +## Using OpenCV in Visual Studio Code {#tutorial_windows_msys2_vscode_section} + +Install the following extensions in **VS Code**: + +- C/C++ +- CMake Tools + +Open your project folder in VS Code. + +Configure the project using CMake. + +@code{.bash} +cmake -G "MinGW Makefiles" .. +@endcode + +Build the project. + +@code{.bash} +mingw32-make +@endcode + +Run the executable. + +--- + +## Troubleshooting {#tutorial_windows_msys2_install_troubleshoot} + +### CMake cannot find OpenCV + +Ensure that `OpenCV_DIR` is set correctly. + +Example: + +@code{.cmake} +set(OpenCV_DIR "C:/path/to/opencv/build/install/lib/cmake/opencv4") +@endcode + +--- + +### mingw32-make not found + +Make sure the following path is added to the Windows environment variable **PATH**: `C:\msys64\ucrt64\bin` + +--- + +### Build fails due to memory limits + +Reduce parallel build jobs. + +@code{.bash} +mingw32-make -j2 +@endcode + +--- + +## Conclusion + +You have successfully built OpenCV from source using **MSYS2 UCRT64** and verified it with a **C++ project in VS Code**. + +This setup allows you to develop OpenCV-based C++ applications using a fully open-source toolchain on Windows. From 18c7c9bcb98eba7ecad47fba7c6fdbc99262551d Mon Sep 17 00:00:00 2001 From: Madan mohan Manokar Date: Fri, 13 Mar 2026 13:41:20 +0530 Subject: [PATCH 27/32] Merge pull request #28614 from amd:fast_flipHoriz Optimized flip Horizontal #28614 - Refactor flipHoriz implementation. - Optimizations for horizontal image flipping added. ### 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 --- modules/core/src/matrix_transform.cpp | 382 ++++++++++++++------------ 1 file changed, 202 insertions(+), 180 deletions(-) diff --git a/modules/core/src/matrix_transform.cpp b/modules/core/src/matrix_transform.cpp index c52fcc1e4f..977a4cb973 100644 --- a/modules/core/src/matrix_transform.cpp +++ b/modules/core/src/matrix_transform.cpp @@ -1,7 +1,7 @@ // 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 "opencl_kernels_core.hpp" #include "hal_replacement.hpp" @@ -285,40 +285,63 @@ void transposeND(InputArray src_, const std::vector& order, OutputArray dst } -#if CV_SIMD128 -template CV_ALWAYS_INLINE void flipHoriz_single( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz ) +// Generic scalar fallback +CV_ALWAYS_INLINE void flipHoriz_generic( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz ) +{ + int i, j, limit = (int)(((size.width + 1)/2)*esz); + int height = size.height; + AutoBuffer _tab(size.width*esz); + int* tab = _tab.data(); + + for( i = 0; i < size.width; i++ ) + for( size_t k = 0; k < esz; k++ ) + tab[i*esz + k] = (int)((size.width - i - 1)*esz + k); + + for( ; height--; src += sstep, dst += dstep ) + { + for( i = 0; i < limit; i++ ) + { + j = tab[i]; + uchar t0 = src[i], t1 = src[j]; + dst[i] = t1; dst[j] = t0; + } + } +} + +#if CV_SIMD || CV_SIMD_SCALABLE +template CV_ALWAYS_INLINE void flipHoriz_single( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size ) { typedef typename VTraits::lane_type T; - int end = (int)(size.width*esz); - int width = (end + 1)/2; - int width_1 = width & -VTraits::vlanes(); - int i, j; + const int vlanes = VTraits::vlanes(); + int end = (int)(size.width * sizeof(T)); + int width = (end + 1) / 2; + int width_simd = width & -vlanes; + int height = size.height; #if CV_STRONG_ALIGNMENT CV_Assert(isAligned(src, dst)); #endif - for( ; size.height--; src += sstep, dst += dstep ) + for( ; height--; src += sstep, dst += dstep ) { - for( i = 0, j = end; i < width_1; i += VTraits::vlanes(), j -= VTraits::vlanes() ) + int i = 0, j = end; + for( ; i < width_simd; i += vlanes, j -= vlanes ) { - V t0, t1; - - t0 = v_load((T*)((uchar*)src + i)); - t1 = v_load((T*)((uchar*)src + j - VTraits::vlanes())); + V t0 = vx_load((const T*)(src + i)); + V t1 = vx_load((const T*)(src + j - vlanes)); t0 = v_reverse(t0); t1 = v_reverse(t1); - v_store((T*)(dst + j - VTraits::vlanes()), t0); + v_store((T*)(dst + j - vlanes), t0); v_store((T*)(dst + i), t1); } + + // Scalar tail loop if (isAligned(src, dst)) { for ( ; i < width; i += sizeof(T), j -= sizeof(T) ) { - T t0, t1; - - t0 = *((T*)((uchar*)src + i)); - t1 = *((T*)((uchar*)src + j - sizeof(T))); + T t0 = *((const T*)(src + i)); + T t1 = *((const T*)(src + j - sizeof(T))); *((T*)(dst + j - sizeof(T))) = t0; *((T*)(dst + i)) = t1; } @@ -329,195 +352,194 @@ template CV_ALWAYS_INLINE void flipHoriz_single( const uchar* src, s { for (int k = 0; k < (int)sizeof(T); k++) { - uchar t0, t1; - - t0 = *((uchar*)src + i + k); - t1 = *((uchar*)src + j + k - sizeof(T)); - *(dst + j + k - sizeof(T)) = t0; - *(dst + i + k) = t1; + uchar t0 = src[i + k]; + uchar t1 = src[j + k - sizeof(T)]; + dst[j + k - sizeof(T)] = t0; + dst[i + k] = t1; } } } } } -template CV_ALWAYS_INLINE void flipHoriz_double( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz ) +// SIMD for C3 +template +CV_ALWAYS_INLINE void flipHoriz_c3( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size ) { - int end = (int)(size.width*esz); - int width = (end + 1)/2; + typedef typename VTraits::lane_type T; + const int vlanes = VTraits::vlanes(); + const int stride = 3 * sizeof(T); + int width = size.width; + int centre = (width + 1) / 2; + int width_simd = (centre / vlanes) * vlanes; + int height = size.height; -#if CV_STRONG_ALIGNMENT - CV_Assert(isAligned(src, dst)); - CV_Assert(isAligned(src, dst)); -#endif - - for( ; size.height--; src += sstep, dst += dstep ) + for( ; height--; src += sstep, dst += dstep ) { - for ( int i = 0, j = end; i < width; i += sizeof(T1) + sizeof(T2), j -= sizeof(T1) + sizeof(T2) ) + int i = 0; + for( ; i < width_simd; i += vlanes ) { - T1 t0, t1; - T2 t2, t3; - - t0 = *((T1*)((uchar*)src + i)); - t2 = *((T2*)((uchar*)src + i + sizeof(T1))); - t1 = *((T1*)((uchar*)src + j - sizeof(T1) - sizeof(T2))); - t3 = *((T2*)((uchar*)src + j - sizeof(T2))); - *((T1*)(dst + j - sizeof(T1) - sizeof(T2))) = t0; - *((T2*)(dst + j - sizeof(T2))) = t2; - *((T1*)(dst + i)) = t1; - *((T2*)(dst + i + sizeof(T1))) = t3; + V r0, g0, b0; + v_load_deinterleave((const T*)(src + i * stride), r0, g0, b0); + V r1, g1, b1; + v_load_deinterleave((const T*)(src + (width - i - vlanes) * stride), r1, g1, b1); + r0 = v_reverse(r0); + g0 = v_reverse(g0); + b0 = v_reverse(b0); + r1 = v_reverse(r1); + g1 = v_reverse(g1); + b1 = v_reverse(b1); + v_store_interleave((T*)(dst + (width - i - vlanes) * stride), r0, g0, b0); + v_store_interleave((T*)(dst + i * stride), r1, g1, b1); + } + // Scalar tail loop for remaining pixels + for( ; i < centre; i++ ) + { + int j = width - i - 1; + T c0 = ((const T*)(src + i * stride))[0]; + T c1 = ((const T*)(src + i * stride))[1]; + T c2 = ((const T*)(src + i * stride))[2]; + T c3 = ((const T*)(src + j * stride))[0]; + T c4 = ((const T*)(src + j * stride))[1]; + T c5 = ((const T*)(src + j * stride))[2]; + ((T*)(dst + j * stride))[0] = c0; + ((T*)(dst + j * stride))[1] = c1; + ((T*)(dst + j * stride))[2] = c2; + ((T*)(dst + i * stride))[0] = c3; + ((T*)(dst + i * stride))[1] = c4; + ((T*)(dst + i * stride))[2] = c5; } } } -#endif -static void -flipHoriz( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz ) +// SIMD flip when ESZ multiple of vlanes +template +CV_ALWAYS_INLINE void flipHoriz_vlanes_match( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size) { + const int vlanes = VTraits::vlanes(); + int end = (int)(size.width * ESZ); + int width = end / 2; + int height = size.height; + int eSize = (int)ESZ; + for( ; height--; src += sstep, dst += dstep ) + { + for( int i = 0, j = end - eSize; i < width; i += eSize, j -= eSize ) + { + for( int k = 0; k < eSize; k += vlanes ) + { + v_uint8 t0 = vx_load(src + i + k); + v_uint8 t1 = vx_load(src + j + k); + v_store(dst + j + k, t0); + v_store(dst + i + k, t1); + } + } + } +} + #if CV_SIMD128 -#if CV_STRONG_ALIGNMENT - size_t alignmentMark = ((size_t)src)|((size_t)dst)|sstep|dstep; -#endif - if (esz == 2 * (size_t)VTraits::vlanes()) +// SIMD flip when ESZ=16 (128-bit) +template +CV_ALWAYS_INLINE void flipHoriz_vlanes_match_128( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size) +{ + const int vlanes16 = VTraits::vlanes(); + int end = (int)(size.width * ESZ); + int width = end / 2; + int height = size.height; + for( ; height--; src += sstep, dst += dstep ) { - int end = (int)(size.width*esz); - int width = end/2; - - for( ; size.height--; src += sstep, dst += dstep ) + for( int i = 0, j = end - vlanes16; i < width; i += vlanes16, j -= vlanes16 ) { - for( int i = 0, j = end - 2 * VTraits::vlanes(); i < width; i += 2 * VTraits::vlanes(), j -= 2 * VTraits::vlanes() ) - { -#if CV_SIMD256 - v_uint8x32 t0, t1; - - t0 = v256_load((uchar*)src + i); - t1 = v256_load((uchar*)src + j); - v_store(dst + j, t0); - v_store(dst + i, t1); -#else - v_uint8x16 t0, t1, t2, t3; - - t0 = v_load((uchar*)src + i); - t1 = v_load((uchar*)src + i + VTraits::vlanes()); - t2 = v_load((uchar*)src + j); - t3 = v_load((uchar*)src + j + VTraits::vlanes()); - v_store(dst + j, t0); - v_store(dst + j + VTraits::vlanes(), t1); - v_store(dst + i, t2); - v_store(dst + i + VTraits::vlanes(), t3); -#endif - } + v_uint8x16 t0 = v_load(src + i); + v_uint8x16 t1 = v_load(src + j); + v_store(dst + j, t0); + v_store(dst + i, t1); } } - else if (esz == (size_t)VTraits::vlanes()) - { - int end = (int)(size.width*esz); - int width = end/2; - - for( ; size.height--; src += sstep, dst += dstep ) - { - for( int i = 0, j = end - VTraits::vlanes(); i < width; i += VTraits::vlanes(), j -= VTraits::vlanes() ) - { - v_uint8x16 t0, t1; - - t0 = v_load((uchar*)src + i); - t1 = v_load((uchar*)src + j); - v_store(dst + j, t0); - v_store(dst + i, t1); - } - } - } - else if (esz == 8 -#if CV_STRONG_ALIGNMENT - && isAligned(alignmentMark) -#endif - ) - { - flipHoriz_single(src, sstep, dst, dstep, size, esz); - } - else if (esz == 4 -#if CV_STRONG_ALIGNMENT - && isAligned(alignmentMark) -#endif - ) - { - flipHoriz_single(src, sstep, dst, dstep, size, esz); - } - else if (esz == 2 -#if CV_STRONG_ALIGNMENT - && isAligned(alignmentMark) -#endif - ) - { - flipHoriz_single(src, sstep, dst, dstep, size, esz); - } - else if (esz == 1) - { - flipHoriz_single(src, sstep, dst, dstep, size, esz); - } - else if (esz == 24 -#if CV_STRONG_ALIGNMENT - && isAligned(alignmentMark) -#endif - ) - { - int end = (int)(size.width*esz); - int width = (end + 1)/2; - - for( ; size.height--; src += sstep, dst += dstep ) - { - for ( int i = 0, j = end; i < width; i += VTraits::vlanes() + sizeof(uint64_t), j -= VTraits::vlanes() + sizeof(uint64_t) ) - { - v_uint8x16 t0, t1; - uint64_t t2, t3; - - t0 = v_load((uchar*)src + i); - t2 = *((uint64_t*)((uchar*)src + i + VTraits::vlanes())); - t1 = v_load((uchar*)src + j - VTraits::vlanes() - sizeof(uint64_t)); - t3 = *((uint64_t*)((uchar*)src + j - sizeof(uint64_t))); - v_store(dst + j - VTraits::vlanes() - sizeof(uint64_t), t0); - *((uint64_t*)(dst + j - sizeof(uint64_t))) = t2; - v_store(dst + i, t1); - *((uint64_t*)(dst + i + VTraits::vlanes())) = t3; - } - } - } -#if !CV_STRONG_ALIGNMENT - else if (esz == 12) - { - flipHoriz_double(src, sstep, dst, dstep, size, esz); - } - else if (esz == 6) - { - flipHoriz_double(src, sstep, dst, dstep, size, esz); - } - else if (esz == 3) - { - flipHoriz_double(src, sstep, dst, dstep, size, esz); - } -#endif - else +} #endif // CV_SIMD128 + +// SIMD flip for ESZ=16,32 +template +CV_ALWAYS_INLINE void flipHoriz_vlanes_dispatch( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size ) +{ + const int vlanes = VTraits::vlanes(); +#if CV_SIMD128 + const int vlanes16 = VTraits::vlanes(); +#endif + if ( (ESZ == (size_t)vlanes) || (ESZ == 2 * (size_t)vlanes)) { - int i, j, limit = (int)(((size.width + 1)/2)*esz); - AutoBuffer _tab(size.width*esz); - int* tab = _tab.data(); + flipHoriz_vlanes_match(src, sstep, dst, dstep, size); + return; + } +#if CV_SIMD128 + else if (ESZ == vlanes16) + { + flipHoriz_vlanes_match_128(src, sstep, dst, dstep, size); + return; + } +#endif + flipHoriz_generic(src, sstep, dst, dstep, size, ESZ); +} - for( i = 0; i < size.width; i++ ) - for( size_t k = 0; k < esz; k++ ) - tab[i*esz + k] = (int)((size.width - i - 1)*esz + k); - - for( ; size.height--; src += sstep, dst += dstep ) +#if CV_SIMD128 +// SIMD flip for ESZ=24 (CV_64FC3) +CV_ALWAYS_INLINE void flipHoriz_24( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size ) +{ +#if CV_STRONG_ALIGNMENT + // This kernel performs 64-bit scalar loads/stores, so require 8-byte alignment. + if (!isAligned<8>(((size_t)src)|((size_t)dst)|sstep|dstep)) + { + flipHoriz_generic(src, sstep, dst, dstep, size, 24); + return; + } +#endif + const int lanes16 = 16; + int end = (int)(size.width * 24); + int width = (end + 1) / 2; + int height = size.height; + for( ; height--; src += sstep, dst += dstep ) + { + for ( int i = 0, j = end; i < width; i += lanes16 + 8, j -= lanes16 + 8 ) { - for( i = 0; i < limit; i++ ) - { - j = tab[i]; - uchar t0 = src[i], t1 = src[j]; - dst[i] = t1; dst[j] = t0; - } + v_uint8x16 t0 = v_load(src + i); + uint64_t t2 = *reinterpret_cast(src + i + lanes16); + v_uint8x16 t1 = v_load(src + j - lanes16 - 8); + uint64_t t3 = *reinterpret_cast(src + j - 8); + v_store(dst + j - lanes16 - 8, t0); + *reinterpret_cast(dst + j - 8) = t2; + v_store(dst + i, t1); + *reinterpret_cast(dst + i + lanes16) = t3; } } } +#endif // CV_SIMD128 +#endif // CV_SIMD || CV_SIMD_SCALABLE + +static void flipHoriz( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size, size_t esz ) +{ +#if CV_SIMD || CV_SIMD_SCALABLE + // SIMD-optimized dispatch + switch(esz) + { + case 1: flipHoriz_single(src, sstep, dst, dstep, size); return; // CV_8UC1: 8-bit, 1 channel + case 2: flipHoriz_single(src, sstep, dst, dstep, size); return; // CV_8UC2, CV_16UC1: 8-bit 2-channel or 16-bit 1-channel + case 3: flipHoriz_c3(src, sstep, dst, dstep, size); return; // CV_8UC3: 8-bit, 3 channels + case 4: flipHoriz_single(src, sstep, dst, dstep, size); return; // CV_8UC4, CV_16UC2, CV_32SC1, CV_32FC1: 8-bit 4-channel, 16-bit 2-channel, or 32-bit 1-channel + case 6: flipHoriz_c3(src, sstep, dst, dstep, size); return; // CV_16UC3, CV_16SC3: 16-bit, 3 channels + case 8: flipHoriz_single(src, sstep, dst, dstep, size); return; // CV_16UC4, CV_32SC2, CV_32FC2, CV_64FC1: 16-bit 4-channel, 32-bit 2-channel, or 64-bit 1-channel + case 12: flipHoriz_c3(src, sstep, dst, dstep, size); return; // CV_32SC3, CV_32FC3: 32-bit, 3 channels + case 16: flipHoriz_vlanes_dispatch<16>(src, sstep, dst, dstep, size); return; // CV_32SC4, CV_32FC4, CV_64FC2: 32-bit 4-channel or 64-bit 2-channel +#if CV_SIMD128 + case 24: flipHoriz_24(src, sstep, dst, dstep, size); return; // CV_64FC3: 64-bit, 3 channels +#endif + case 32: flipHoriz_vlanes_dispatch<32>(src, sstep, dst, dstep, size); return; // CV_64FC4: 64-bit, 4 channels + default: + break; // Fall through to generic implementation + } +#endif + // Fallback: generic scalar + flipHoriz_generic(src, sstep, dst, dstep, size, esz); +} static void flipVert( const uchar* src0, size_t sstep, uchar* dst0, size_t dstep, Size size, size_t esz ) From 00833f98d0aed4e299a8ba5723d06456e6d077ee Mon Sep 17 00:00:00 2001 From: Madan mohan Manokar Date: Fri, 13 Mar 2026 15:34:46 +0530 Subject: [PATCH 28/32] Merge pull request #28632 from amd:fast_scharr_deriv video: Optimized ScharrDeriv#28632 - Move to CV_SIMD_SCALABLE - avx2 & avx512 dispatch added for ScharrDeriv ### 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 --- modules/video/CMakeLists.txt | 1 + modules/video/src/lkpyramid.cpp | 81 +--------------- modules/video/src/lkpyramid.dispatch.cpp | 22 +++++ modules/video/src/lkpyramid.hpp | 2 + modules/video/src/lkpyramid.simd.hpp | 118 +++++++++++++++++++++++ 5 files changed, 145 insertions(+), 79 deletions(-) create mode 100644 modules/video/src/lkpyramid.dispatch.cpp create mode 100644 modules/video/src/lkpyramid.simd.hpp diff --git a/modules/video/CMakeLists.txt b/modules/video/CMakeLists.txt index a302e5a5d1..5ea22b45cb 100644 --- a/modules/video/CMakeLists.txt +++ b/modules/video/CMakeLists.txt @@ -1,4 +1,5 @@ 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 diff --git a/modules/video/src/lkpyramid.cpp b/modules/video/src/lkpyramid.cpp index 1ed0482447..35f1e6135d 100644 --- a/modules/video/src/lkpyramid.cpp +++ b/modules/video/src/lkpyramid.cpp @@ -12,6 +12,7 @@ // // 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, @@ -73,85 +74,7 @@ static void calcScharrDeriv(const cv::Mat& src, cv::Mat& dst) void cv::detail::ScharrDerivInvoker::operator()(const Range& range) const { - using cv::detail::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 _tempBuf(delta*2 + 64); - deriv_type *trow0 = alignPtr(_tempBuf.data() + cn, 16), *trow1 = alignPtr(trow0 + delta, 16); - -#if CV_SIMD128 - v_int16x8 c3 = v_setall_s16(3), c10 = v_setall_s16(10); -#endif - - for( y = range.start; y < range.end; y++ ) - { - const uchar* srow0 = src.ptr(y > 0 ? y-1 : rows > 1 ? 1 : 0); - const uchar* srow1 = src.ptr(y); - const uchar* srow2 = src.ptr(y < rows-1 ? y+1 : rows > 1 ? rows-2 : 0); - deriv_type* drow = (deriv_type *)dst.ptr(y); - - // do vertical convolution - x = 0; -#if CV_SIMD128 - { - for( ; x <= colsn - 8; x += 8 ) - { - v_int16x8 s0 = v_reinterpret_as_s16(v_load_expand(srow0 + x)); - v_int16x8 s1 = v_reinterpret_as_s16(v_load_expand(srow1 + x)); - v_int16x8 s2 = v_reinterpret_as_s16(v_load_expand(srow2 + x)); - - v_int16x8 t1 = v_sub(s2, s0); - v_int16x8 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_SIMD128 - { - for( ; x <= colsn - 8; x += 8 ) - { - v_int16x8 s0 = v_load(trow0 + x - cn); - v_int16x8 s1 = v_load(trow0 + x + cn); - v_int16x8 s2 = v_load(trow1 + x - cn); - v_int16x8 s3 = v_load(trow1 + x); - v_int16x8 s4 = v_load(trow1 + x + cn); - - v_int16x8 t0 = v_sub(s1, s0); - v_int16x8 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; - } - } + ScharrDerivInvoker_impl(src, const_cast(dst), range); } cv::detail::LKTrackerInvoker::LKTrackerInvoker( diff --git a/modules/video/src/lkpyramid.dispatch.cpp b/modules/video/src/lkpyramid.dispatch.cpp new file mode 100644 index 0000000000..2775d9af0a --- /dev/null +++ b/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/modules/video/src/lkpyramid.hpp b/modules/video/src/lkpyramid.hpp index 62fab0564b..18ff61c75e 100644 --- a/modules/video/src/lkpyramid.hpp +++ b/modules/video/src/lkpyramid.hpp @@ -7,6 +7,8 @@ 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) diff --git a/modules/video/src/lkpyramid.simd.hpp b/modules/video/src/lkpyramid.simd.hpp new file mode 100644 index 0000000000..4408b8affc --- /dev/null +++ b/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 _tempBuf(delta*2 + 64); + deriv_type *trow0 = alignPtr(_tempBuf.data() + cn, 16), *trow1 = alignPtr(trow0 + delta, 16); + +#if (CV_SIMD) + const int vlanes = VTraits::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(y > 0 ? y-1 : rows > 1 ? 1 : 0); + const uchar* srow1 = src.ptr(y); + const uchar* srow2 = src.ptr(y < rows-1 ? y+1 : rows > 1 ? rows-2 : 0); + deriv_type* drow = (deriv_type *)dst.ptr(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 From 95ab7149feca27b6dd97c3c268e32ee96ac37b09 Mon Sep 17 00:00:00 2001 From: Pavel Guzenfeld <67074795+PavelGuzenfeld@users.noreply.github.com> Date: Sun, 15 Mar 2026 23:21:42 +0200 Subject: [PATCH 29/32] Fix Python bindings when optional modules like gapi are disabled MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix two issues that cause `import cv2` to fail when building with -DBUILD_opencv_gapi=OFF: 1. In `has_all_required_modules()`, the function parameter `type_node` was ignored in favor of the enclosing scope's loop variable `node`. This works by accident when called as `has_all_required_modules(node)` but is incorrect — the parameter should be used directly. 2. In `__load_extra_py_code_for_module()`, only `ImportError` was caught. When a stale gapi submodule directory exists from a previous build, gapi/__init__.py raises `AttributeError` (not `ImportError`) because it tries to access C++ bindings that don't exist. Now catches both exception types for defense-in-depth. Refs: #26098 --- modules/python/package/cv2/__init__.py | 2 +- modules/python/src2/typing_stubs_generation/generation.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/modules/python/package/cv2/__init__.py b/modules/python/package/cv2/__init__.py index 7e148fc9f2..11994a2cd3 100644 --- a/modules/python/package/cv2/__init__.py +++ b/modules/python/package/cv2/__init__.py @@ -26,7 +26,7 @@ def __load_extra_py_code_for_module(base, name, enable_debug_print=False): native_module = sys.modules.pop(module_name, None) try: py_module = importlib.import_module(module_name) - except ImportError as err: + except (ImportError, AttributeError) as err: if enable_debug_print: print("Can't load Python code for module:", module_name, ". Reason:", err) diff --git a/modules/python/src2/typing_stubs_generation/generation.py b/modules/python/src2/typing_stubs_generation/generation.py index 084a37a94b..07de26c0af 100644 --- a/modules/python/src2/typing_stubs_generation/generation.py +++ b/modules/python/src2/typing_stubs_generation/generation.py @@ -708,7 +708,7 @@ def _generate_typing_module(root: NamespaceNode, output_path: Path) -> None: """ def has_all_required_modules(type_node: TypeNode) -> bool: - return all(em in root.namespaces for em in node.required_modules) + return all(em in root.namespaces for em in type_node.required_modules) def register_alias_links_from_aggregated_type(type_node: TypeNode) -> None: assert isinstance(type_node, AggregatedTypeNode), \ From faf36aa95b377b2a4d93f9a8f97c10cd6f4f735b Mon Sep 17 00:00:00 2001 From: CSBVision Date: Mon, 16 Mar 2026 11:28:56 +0100 Subject: [PATCH 30/32] Change file globbing to recursive for CUDA DLLs With recent releases, the CUDA installation layout changes introduces a `bin\x64` subdirectory. Recursive glob inside `bin` works in either case. --- cmake/OpenCVDetectCUDAUtils.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmake/OpenCVDetectCUDAUtils.cmake b/cmake/OpenCVDetectCUDAUtils.cmake index fdd65ef6c3..8d2c87b443 100644 --- a/cmake/OpenCVDetectCUDAUtils.cmake +++ b/cmake/OpenCVDetectCUDAUtils.cmake @@ -439,7 +439,7 @@ endmacro() macro(ocv_check_cuda_delayed_load cuda_toolkit_root_dir) if(MSVC AND CUDA_ENABLE_DELAYLOAD) set(DELAYFLAGS "delayimp.lib") - file(GLOB CUDA_DLLS "${cuda_toolkit_root_dir}/bin/*.dll") + file(GLOB_RECURSE CUDA_DLLS "${cuda_toolkit_root_dir}/bin/*.dll") foreach(d ${CUDA_DLLS}) cmake_path(GET "d" FILENAME DLL_NAME) if(NOT ${DLL_NAME} MATCHES "cudart") From 2dd3d1371a9975248b1c236f4a94295a7ac5777d Mon Sep 17 00:00:00 2001 From: pratham-mcw Date: Mon, 16 Mar 2026 16:21:03 +0530 Subject: [PATCH 31/32] Merge pull request #28636 from pratham-mcw:imgproc_distance_transform_opt imgproc: add SIMD support for distance transform function #28636 - This PR adds OpenCV SIMD intrinsics-based optimizations to the distance transform functions for improved performance. - The optimized implementation uses vectorized operations to accelerate the forward and backward passes of distance computation. - In x64 architecture, distance transform function benefit from IPP-based optimized implementations. However, on ARM64 platforms, the execution falls back to scalar implementation, which results in lower performance. - After introducing these changes, the distance transform functions showed noticeable performance improvements on Windows-ARM64. image - [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 --- modules/imgproc/src/distransform.cpp | 486 +++++++++++++++++++++------ 1 file changed, 384 insertions(+), 102 deletions(-) diff --git a/modules/imgproc/src/distransform.cpp b/modules/imgproc/src/distransform.cpp index 66be0e8ea5..3885bc5320 100644 --- a/modules/imgproc/src/distransform.cpp +++ b/modules/imgproc/src/distransform.cpp @@ -70,7 +70,7 @@ static void distanceTransform_3x3( const Mat& _src, Mat& _temp, Mat& _dist, const float* metrics ) { const int BORDER = 1; - int i, j; + const unsigned int HV_DIST = CV_FLT_TO_FIX( metrics[0], DIST_SHIFT ); const unsigned int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], DIST_SHIFT ); const unsigned int DIST_MAX = UINT_MAX - DIAG_DIST; @@ -79,65 +79,190 @@ distanceTransform_3x3( const Mat& _src, Mat& _temp, Mat& _dist, const float* met const uchar* src = _src.ptr(); int* temp = _temp.ptr(); float* dist = _dist.ptr(_dist.rows - 1); - int srcstep = (int)(_src.step/sizeof(src[0])); - int step = (int)(_temp.step/sizeof(temp[0])); - int dststep = (int)(_dist.step/sizeof(dist[0])); - Size size = _src.size(); + + const int srcstep = (int)_src.step; + const int step = (int)(_temp.step / sizeof(int)); + const int dststep = (int)(_dist.step / sizeof(float)); + + const int width = _src.cols; + const int height = _src.rows; initTopBottom( _temp, BORDER, DIST_MAX ); // forward pass - unsigned int* tmp = (unsigned int*)(temp + BORDER*step) + BORDER; - const uchar* s = src; - for( i = 0; i < size.height; i++ ) - { - for( j = 0; j < BORDER; j++ ) - tmp[-j-1] = tmp[size.width + j] = DIST_MAX; + unsigned int* row = (unsigned int*)(temp + BORDER * step) + BORDER; + const uchar* srow = src; - for( j = 0; j < size.width; j++ ) + for (int i = 0; i < height; i++) + { + unsigned int* cur = row; + const uchar* s = srow; + const unsigned int* top = (const unsigned int*)(cur - step); + + // set horizontal border sentinels + cur[-1] = DIST_MAX; + cur[width] = DIST_MAX; + + unsigned int left = cur[-1]; + +#if defined(CV_SIMD) + const int BLOCK = 8; + int j = 0; + const v_uint32 v_diag = vx_setall(DIAG_DIST); + const v_uint32 v_hv = vx_setall(HV_DIST); + + for (; j <= width - BLOCK; j += BLOCK) { - if( !s[j] ) - tmp[j] = 0; - else + v_uint32 tl0 = vx_load(top + j - 1); + v_uint32 t0 = vx_load(top + j); + v_uint32 tr0 = vx_load(top + j + 1); + v_uint32 tl1 = vx_load(top + j + 3); + v_uint32 t1 = vx_load(top + j + 4); + v_uint32 tr1 = vx_load(top + j + 5); + tl0 = v_add(tl0, v_diag); + t0 = v_add(t0, v_hv); + tr0 = v_add(tr0, v_diag); + tl1 = v_add(tl1, v_diag); + t1 = v_add(t1, v_hv); + tr1 = v_add(tr1, v_diag); + v_uint32 m0 = v_min(tl0, t0); + m0 = v_min(m0, tr0); + v_uint32 m1 = v_min(tl1, t1); + m1 = v_min(m1, tr1); + v_store(cur + j, m0); + v_store(cur + j + 4, m1); + + for (int k = 0; k < BLOCK; k++) { - unsigned int t0 = tmp[j-step-1] + DIAG_DIST; - unsigned int t = tmp[j-step] + HV_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step+1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-1] + HV_DIST; - if( t0 > t ) t0 = t; - tmp[j] = (t0 > DIST_MAX) ? DIST_MAX : t0; + int idx = j + k; + if (!s[idx]) + { + cur[idx] = 0; + left = 0; + } + else + { + unsigned int m = cur[idx]; + unsigned int lm = left + HV_DIST; + if (lm < m) m = lm; + if (m > DIST_MAX) m = DIST_MAX; + cur[idx] = m; + left = m; + } } } - tmp += step; - s += srcstep; + + for (; j < width; j++) + { + if (!s[j]) + { + cur[j] = 0; + left = 0; + } + else + { + unsigned int t0 = top[j - 1] + DIAG_DIST; + unsigned int t1 = top[j] + HV_DIST; + unsigned int t2 = top[j + 1] + DIAG_DIST; + unsigned int t3 = left + HV_DIST; + + unsigned int m = t0 < t1 ? t0 : t1; + m = m < t2 ? m : t2; + m = m < t3 ? m : t3; + + cur[j] = m > DIST_MAX ? DIST_MAX : m; + left = cur[j]; + } + } +#else + for (int j = 0; j < width; j++) + { + if (!s[j]) + { + cur[j] = 0; + left = 0; + } + else + { + unsigned int t0 = top[j - 1] + DIAG_DIST; + unsigned int t1 = top[j] + HV_DIST; + unsigned int t2 = top[j + 1] + DIAG_DIST; + unsigned int t3 = left + HV_DIST; + + unsigned int m = t0 < t1 ? t0 : t1; + m = m < t2 ? m : t2; + m = m < t3 ? m : t3; + + cur[j] = m > DIST_MAX ? DIST_MAX : m; + left = cur[j]; + } + } +#endif + + row += step; + srow += srcstep; } // backward pass - float* d = (float*)dist; - for( i = size.height - 1; i >= 0; i-- ) + float* drow = dist; + unsigned int* cur = row - step; +#if defined(CV_SIMD) + const v_float32 scale_v = vx_setall(scale); +#endif + for (int i = height - 1; i >= 0; i--) { - tmp -= step; + unsigned int* bottom = cur + step; - for( j = size.width - 1; j >= 0; j-- ) + unsigned int right = cur[width]; + for (int j = width - 1; j >= 0; j--) { - unsigned int t0 = tmp[j]; - if( t0 > HV_DIST ) + unsigned int t0 = cur[j]; + + if (t0 > HV_DIST) { - unsigned int t = tmp[j+step+1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step] + HV_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step-1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+1] + HV_DIST; - if( t0 > t ) t0 = t; - tmp[j] = t0; + unsigned int b1 = bottom[j + 1] + DIAG_DIST; + unsigned int b2 = bottom[j] + HV_DIST; + unsigned int b3 = bottom[j - 1] + DIAG_DIST; + unsigned int r = right + HV_DIST; + + unsigned int t = b1 < b2 ? b1 : b2; + t = t < b3 ? t : b3; + t = t < r ? t : r; + + if (t < t0) + { + t0 = t; + cur[j] = t0; + } } - d[j] = (float)(t0 * scale); + + right = cur[j]; } - d -= dststep; + +#if defined(CV_SIMD) + int j = 0; + const uint32_t* tptr = (const uint32_t*)cur; + float* dptr = drow; + + for (; j <= width - 8; j += 8) + { + v_uint32 v0 = vx_load(tptr + j); + v_uint32 v1 = vx_load(tptr + j + 4); + v_float32 f0 = v_mul(v_cvt_f32(v0), scale_v); + v_float32 f1 = v_mul(v_cvt_f32(v1), scale_v); + v_store(dptr + j, f0); + v_store(dptr + j + 4, f1); + } + + for (; j < width; j++) + dptr[j] = (float)(tptr[j] * scale); +#else + for (int j = 0; j < width; j++) + drow[j] = (float)(cur[j] * scale); +#endif + + cur -= step; + drow -= dststep; } } @@ -146,91 +271,248 @@ static void distanceTransform_5x5( const Mat& _src, Mat& _temp, Mat& _dist, const float* metrics ) { const int BORDER = 2; - int i, j; + const unsigned int HV_DIST = CV_FLT_TO_FIX( metrics[0], DIST_SHIFT ); const unsigned int DIAG_DIST = CV_FLT_TO_FIX( metrics[1], DIST_SHIFT ); const unsigned int LONG_DIST = CV_FLT_TO_FIX( metrics[2], DIST_SHIFT ); const unsigned int DIST_MAX = UINT_MAX - LONG_DIST; const float scale = 1.f/(1 << DIST_SHIFT); - const uchar* src = _src.ptr(); + const uchar* src = _src.ptr(); int* temp = _temp.ptr(); float* dist = _dist.ptr(_dist.rows - 1); - int srcstep = (int)(_src.step/sizeof(src[0])); - int step = (int)(_temp.step/sizeof(temp[0])); - int dststep = (int)(_dist.step/sizeof(dist[0])); - Size size = _src.size(); - initTopBottom( _temp, BORDER, DIST_MAX ); + const int srcstep = (int)_src.step; + const int step = (int)(_temp.step / sizeof(int)); + const int dststep = (int)(_dist.step / sizeof(float)); + + const int width = _src.cols; + const int height = _src.rows; + + initTopBottom(_temp, BORDER, DIST_MAX); // forward pass - unsigned int* tmp = (unsigned int*)(temp + BORDER*step) + BORDER; - const uchar* s = src; - for( i = 0; i < size.height; i++ ) - { - for( j = 0; j < BORDER; j++ ) - tmp[-j-1] = tmp[size.width + j] = DIST_MAX; + unsigned int* row = (unsigned int*)(temp + BORDER * step) + BORDER; + const uchar* srow = src; - for( j = 0; j < size.width; j++ ) + for (int i = 0; i < height; i++) + { + unsigned int* cur = row; + const uchar* s = srow; + const unsigned int* top1 = cur - step; + const unsigned int* top2 = cur - step * 2; + cur[-1] = cur[-2] = DIST_MAX; + cur[width] = cur[width + 1] = DIST_MAX; +#if defined(CV_SIMD) + unsigned int left1 = DIST_MAX; + unsigned int left2 = DIST_MAX; + const int BLOCK = 8; + int j = 0; + const v_uint32 v_hv = vx_setall(HV_DIST); + const v_uint32 v_diag = vx_setall(DIAG_DIST); + const v_uint32 v_long = vx_setall(LONG_DIST); + const v_uint32 v_max = vx_setall(DIST_MAX); + + for (; j <= width - BLOCK; j += BLOCK) { - if( !s[j] ) - tmp[j] = 0; - else + v_uint32 t2m1_0 = vx_load(top2 + j - 1); + v_uint32 t2p1_0 = vx_load(top2 + j + 1); + v_uint32 t1m2_0 = vx_load(top1 + j - 2); + v_uint32 t1m1_0 = vx_load(top1 + j - 1); + v_uint32 t1_0 = vx_load(top1 + j); + v_uint32 t1p1_0 = vx_load(top1 + j + 1); + v_uint32 t1p2_0 = vx_load(top1 + j + 2); + + t2m1_0 = v_add(t2m1_0, v_long); + t2p1_0 = v_add(t2p1_0, v_long); + t1m2_0 = v_add(t1m2_0, v_long); + t1m1_0 = v_add(t1m1_0, v_diag); + t1_0 = v_add(t1_0, v_hv); + t1p1_0 = v_add(t1p1_0, v_diag); + t1p2_0 = v_add(t1p2_0, v_long); + + v_uint32 m0 = v_min(t2m1_0, t2p1_0); + v_uint32 m0_1 = v_min(t1m2_0, t1m1_0); + v_uint32 m0_2 = v_min(t1p1_0, t1p2_0); + m0 = v_min(m0, m0_1); + m0_2 = v_min(m0_2, t1_0); + m0 = v_min(m0, m0_2); + m0 = v_min(m0, v_max); + + v_store(cur + j, m0); + + v_uint32 t2m1_1 = vx_load(top2 + j + 3); + v_uint32 t2p1_1 = vx_load(top2 + j + 5); + v_uint32 t1m2_1 = vx_load(top1 + j + 2); + v_uint32 t1m1_1 = vx_load(top1 + j + 3); + v_uint32 t1_1 = vx_load(top1 + j + 4); + v_uint32 t1p1_1 = vx_load(top1 + j + 5); + v_uint32 t1p2_1 = vx_load(top1 + j + 6); + + t2m1_1 = v_add(t2m1_1, v_long); + t2p1_1 = v_add(t2p1_1, v_long); + t1m2_1 = v_add(t1m2_1, v_long); + t1m1_1 = v_add(t1m1_1, v_diag); + t1_1 = v_add(t1_1, v_hv); + t1p1_1 = v_add(t1p1_1, v_diag); + t1p2_1 = v_add(t1p2_1, v_long); + + v_uint32 m1 = v_min(t2m1_1, t2p1_1); + v_uint32 m1_1 = v_min(t1m2_1, t1m1_1); + v_uint32 m1_2 = v_min(t1p1_1, t1p2_1); + m1 = v_min(m1, m1_1); + m1_2 = v_min(m1_2, t1_1); + m1 = v_min(m1, m1_2); + m1 = v_min(m1, v_max); + + v_store(cur + j + 4, m1); + + for (int k = 0; k < BLOCK; k++) { - unsigned int t0 = tmp[j-step*2-1] + LONG_DIST; - unsigned int t = tmp[j-step*2+1] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step-2] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step-1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step] + HV_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step+1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-step+2] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j-1] + HV_DIST; - if( t0 > t ) t0 = t; - tmp[j] = (t0 > DIST_MAX) ? DIST_MAX : t0; + int idx = j + k; + if (!s[idx]) + { + cur[idx] = 0; + left1 = 0; + left2 = 0; + } + else + { + unsigned int m = cur[idx]; + unsigned int lm = left1 + HV_DIST; + if (lm < m) m = lm; + if (m > DIST_MAX) m = DIST_MAX; + cur[idx] = m; + left2 = left1; + left1 = m; + } } } - tmp += step; - s += srcstep; + + for (; j < width; j++) + { + if (!s[j]) + { + cur[j] = 0; + left1 = left2 = 0; + } + else + { + unsigned int t0 = top2[j - 1] + LONG_DIST; + unsigned int t = top2[j + 1] + LONG_DIST; + if (t < t0) t0 = t; + t = top1[j - 2] + LONG_DIST; if (t < t0) t0 = t; + t = top1[j - 1] + DIAG_DIST; if (t < t0) t0 = t; + t = top1[j] + HV_DIST; if (t < t0) t0 = t; + t = top1[j + 1] + DIAG_DIST; if (t < t0) t0 = t; + t = top1[j + 2] + LONG_DIST; if (t < t0) t0 = t; + t = left1 + HV_DIST; if (t < t0) t0 = t; + + cur[j] = t0 > DIST_MAX ? DIST_MAX : t0; + left2 = left1; + left1 = cur[j]; + } + } +#else + unsigned int left = DIST_MAX; + for (int j = 0; j < width; j++) + { + if (!s[j]) + { + cur[j] = 0; + left = 0; + } + else + { + unsigned int t0 = top2[j - 1] + LONG_DIST; + unsigned int t = top2[j + 1] + LONG_DIST; + if (t < t0) t0 = t; + t = top1[j - 2] + LONG_DIST; + if (t < t0) t0 = t; + t = top1[j - 1] + DIAG_DIST; + if (t < t0) t0 = t; + t = top1[j] + HV_DIST; + if (t < t0) t0 = t; + t = top1[j + 1] + DIAG_DIST; + if (t < t0) t0 = t; + t = top1[j + 2] + LONG_DIST; + if (t < t0) t0 = t; + t = left + HV_DIST; + if (t < t0) t0 = t; + cur[j] = t0 > DIST_MAX ? DIST_MAX : t0; + left = cur[j]; + } + } +#endif + row += step; + srow += srcstep; } // backward pass - float* d = (float*)dist; - for( i = size.height - 1; i >= 0; i-- ) - { - tmp -= step; + float* drow = dist; + unsigned int* cur = row - step; - for( j = size.width - 1; j >= 0; j-- ) +#if defined(CV_SIMD) + const v_float32 scale_v = vx_setall(scale); +#endif + + for (int i = height - 1; i >= 0; i--) + { + unsigned int* bot1 = cur + step; + unsigned int* bot2 = cur + step * 2; + unsigned int right = DIST_MAX; + + for (int j = width - 1; j >= 0; j--) { - unsigned int t0 = tmp[j]; + unsigned int t0 = cur[j]; if( t0 > HV_DIST ) { - unsigned int t = tmp[j+step*2+1] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step*2-1] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step+2] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step+1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step] + HV_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step-1] + DIAG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+step-2] + LONG_DIST; - if( t0 > t ) t0 = t; - t = tmp[j+1] + HV_DIST; - if( t0 > t ) t0 = t; - tmp[j] = t0; + unsigned int t = bot2[j + 1] + LONG_DIST; + if (t < t0) t0 = t; + t = bot2[j - 1] + LONG_DIST; + if (t < t0) t0 = t; + t = bot1[j + 2] + LONG_DIST; + if (t < t0) t0 = t; + t = bot1[j + 1] + DIAG_DIST; + if (t < t0) t0 = t; + t = bot1[j] + HV_DIST; + if (t < t0) t0 = t; + t = bot1[j - 1] + DIAG_DIST; + if (t < t0) t0 = t; + t = bot1[j - 2] + LONG_DIST; + if (t < t0) t0 = t; + t = right + HV_DIST; + if (t < t0) t0 = t; + + cur[j] = t0; } - d[j] = (float)(t0 * scale); + right = cur[j]; } - d -= dststep; + +#if defined(CV_SIMD) + int j = 0; + const uint32_t* tptr = (const uint32_t*)cur; + float* dptr = drow; + + for (; j <= width - 8; j += 8) + { + v_uint32 v0 = vx_load(tptr + j); + v_uint32 v1 = vx_load(tptr + j + 4); + v_float32 f0 = v_mul(v_cvt_f32(v0), scale_v); + v_float32 f1 = v_mul(v_cvt_f32(v1), scale_v); + v_store(dptr + j, f0); + v_store(dptr + j + 4, f1); + } + + for (; j < width; j++) + dptr[j] = (float)(tptr[j] * scale); +#else + for (int j = 0; j < width; j++) + drow[j] = (float)(cur[j] * scale); +#endif + + cur -= step; + drow -= dststep; } } From 3779f630bca0715f696c9e366b0ee734763a21d7 Mon Sep 17 00:00:00 2001 From: Pavel Guzenfeld Date: Mon, 16 Mar 2026 23:41:37 +0200 Subject: [PATCH 32/32] Clean up stale typing stubs during incremental builds When a module is disabled in an incremental build (e.g. switching from -DBUILD_opencv_gapi=ON to OFF), its typing stub directory persists from the previous build. The stubs generator only creates directories for enabled modules but never removes old ones, and the copy step merges rather than replaces, so stale .pyi files propagate to both the loader directory and the install prefix. This causes type-checkers (mypy, pyright) to report errors for stubs that reference symbols from modules that are no longer available. Fix both propagation paths: - generation.py: remove all subdirectories under the stubs output root before regenerating, so only currently enabled module stubs exist in the build directory. Top-level files (py.typed) are preserved. - copy_typings_stubs_on_success.py: remove stale .pyi files and py.typed markers from the loader directory before copying fresh stubs, so leftover stubs from a previous copy are cleaned up. Runtime .py files are not affected. --- .../src2/copy_typings_stubs_on_success.py | 17 ++++++++++++++ .../typing_stubs_generation/generation.py | 23 +++++++++++++++++++ 2 files changed, 40 insertions(+) diff --git a/modules/python/src2/copy_typings_stubs_on_success.py b/modules/python/src2/copy_typings_stubs_on_success.py index efcf84ee82..eb5a2e4e6c 100644 --- a/modules/python/src2/copy_typings_stubs_on_success.py +++ b/modules/python/src2/copy_typings_stubs_on_success.py @@ -13,6 +13,21 @@ else: from distutils.dir_util import copy_tree +def _remove_stale_pyi_files(directory): + """Remove .pyi files and py.typed markers from the directory tree. + + During incremental builds, disabling a previously enabled module leaves + stale typing stubs in the loader directory from a previous copy. Since + copy_tree merges rather than replaces, those stale files persist. + Removing all stub files before copying ensures only stubs for currently + enabled modules are present. Runtime .py files are not affected. + """ + for dirpath, dirnames, filenames in os.walk(directory): + for fname in filenames: + if fname.endswith('.pyi') or fname == 'py.typed': + os.remove(os.path.join(dirpath, fname)) + + def main(): args = parse_arguments() py_typed_path = os.path.join(args.stubs_dir, 'py.typed') @@ -24,6 +39,8 @@ def main(): 'generation phase.'.format(py_typed_path) ) return + if os.path.isdir(args.output_dir): + _remove_stale_pyi_files(args.output_dir) copy_tree(args.stubs_dir, args.output_dir) diff --git a/modules/python/src2/typing_stubs_generation/generation.py b/modules/python/src2/typing_stubs_generation/generation.py index 07de26c0af..f27f64df0a 100644 --- a/modules/python/src2/typing_stubs_generation/generation.py +++ b/modules/python/src2/typing_stubs_generation/generation.py @@ -3,6 +3,7 @@ __all__ = ("generate_typing_stubs", ) from io import StringIO from pathlib import Path import re +import shutil from typing import (Callable, NamedTuple, Union, Set, Dict, Collection, Tuple, List) import warnings @@ -24,6 +25,22 @@ from .nodes.type_node import (TypeNode, AliasTypeNode, AliasRefTypeNode, ConditionalAliasTypeNode, PrimitiveTypeNode) +def _clean_stale_stubs_dirs(stubs_root: Path) -> None: + """Remove all subdirectories under stubs_root. + + During incremental builds, disabling a previously enabled module leaves + behind its typing stub directory (e.g. cv2/gapi/). Removing all + subdirectories before regeneration ensures only stubs for currently + enabled modules are present. Top-level files (py.typed, __init__.pyi) + are kept because they are managed separately. + """ + if not stubs_root.is_dir(): + return + for item in stubs_root.iterdir(): + if item.is_dir(): + shutil.rmtree(item) + + def generate_typing_stubs(root: NamespaceNode, output_path: Path): """Generates typing stubs for the AST with root `root` and outputs created files tree to directory pointed by `output_path`. @@ -88,6 +105,12 @@ def generate_typing_stubs(root: NamespaceNode, output_path: Path): # The whole process should fail !only! when all possible scopes are # checked and at least 1 node is still unresolved. root.resolve_type_nodes() + # Remove stale typing stub subdirectories from previous builds. + # In incremental builds, disabling a module (e.g. -DBUILD_opencv_gapi=OFF) + # no longer generates its stubs, but leftover directories from a previous + # build persist and propagate through the copy/install steps, causing + # type-checker errors for stubs referencing unavailable modules. + _clean_stale_stubs_dirs(Path(output_path) / root.export_name) _generate_typing_module(root, output_path) _populate_reexported_symbols(root) _generate_typing_stubs(root, output_path)