diff --git a/hal/ipp/CMakeLists.txt b/hal/ipp/CMakeLists.txt index 06022e2a84..fb4e9ad312 100644 --- a/hal/ipp/CMakeLists.txt +++ b/hal/ipp/CMakeLists.txt @@ -25,6 +25,7 @@ add_library(ipphal STATIC "${CMAKE_CURRENT_SOURCE_DIR}/src/matchtemplate_ipp.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/canny_ipp.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/src/threshold_ipp.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/distancetransform_ipp.cpp" ) #TODO: HAVE_IPP_ICV and HAVE_IPP_IW added as private macro till OpenCV itself is diff --git a/hal/ipp/include/ipp_hal_imgproc.hpp b/hal/ipp/include/ipp_hal_imgproc.hpp index 28a447035e..5c86281817 100644 --- a/hal/ipp/include/ipp_hal_imgproc.hpp +++ b/hal/ipp/include/ipp_hal_imgproc.hpp @@ -149,6 +149,11 @@ int ipp_hal_threshold(const uchar* src_data, size_t src_step, uchar* dst_data, s #undef cv_hal_threshold #define cv_hal_threshold ipp_hal_threshold +int ipp_hal_distanceTransform(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, + int width, int height, int dst_type, int dist_type, int mask_size); +#undef cv_hal_distanceTransform +#define cv_hal_distanceTransform ipp_hal_distanceTransform + #endif // IPP_VERSION_X100 >= 700 #define IPP_DISABLE_PERF_CANNY_MT 1 // cv::Canny OpenCV MT performance is better diff --git a/hal/ipp/src/distancetransform_ipp.cpp b/hal/ipp/src/distancetransform_ipp.cpp new file mode 100644 index 0000000000..e15ce37c12 --- /dev/null +++ b/hal/ipp/src/distancetransform_ipp.cpp @@ -0,0 +1,148 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html +// Copyright (C) 2026, BigVision LLC, all rights reserved. +// Third party copyrights are property of their respective owners. + +#include "ipp_hal_imgproc.hpp" + +#include +#include + +#include +#include + +#if IPP_VERSION_X100 >= 700 + +// Mirrors CV_IPP_MALLOC from modules/core/include/opencv2/core/private.hpp: ippicv (IPP >= 2017) +// exposes only the 64-bit ippMalloc_L. +#if IPP_VERSION_X100 >= 201700 +#define IPP_HAL_MALLOC(SIZE) ippMalloc_L(SIZE) +#else +#define IPP_HAL_MALLOC(SIZE) ippMalloc((int)(SIZE)) +#endif + +#ifndef IPP_DISABLE_PERF_TRUE_DIST_MT +#define IPP_DISABLE_PERF_TRUE_DIST_MT 1 +#endif + +// Fixed distance-transform mask weights, mirroring getDistanceTransformMask() in +// modules/imgproc/src/distransform.cpp. maskType == distTypeIndex + mask_size*10. +static bool ippGetDistanceTransformMask(int dist_type, int mask_size, float *metrics) +{ + int maskType = (dist_type == cv::DIST_C ? 0 : dist_type == cv::DIST_L1 ? 1 : 2) + mask_size * 10; + switch (maskType) + { + case 30: metrics[0] = 1.0f; metrics[1] = 1.0f; break; + case 31: metrics[0] = 1.0f; metrics[1] = 2.0f; break; + case 32: metrics[0] = 0.955f; metrics[1] = 1.3693f; break; + case 50: metrics[0] = 1.0f; metrics[1] = 1.0f; metrics[2] = 2.0f; break; + case 51: metrics[0] = 1.0f; metrics[1] = 2.0f; metrics[2] = 3.0f; break; + case 52: metrics[0] = 1.0f; metrics[1] = 1.4f; metrics[2] = 2.1969f; break; + default: + return false; + } + return true; +} + +int ipp_hal_distanceTransform(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, + int width, int height, int dst_type, int dist_type, int mask_size) +{ + CV_HAL_CHECK_USE_IPP(); + + IppiSize roi = { width, height }; + + // DIST_L1 with 8-bit output: fixed L1 / 3x3 metrics. + if (dst_type == CV_8U) + { + Ipp32s pMetrics[2] = { 1, 2 }; // L1, 3x3 mask + if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_3x3_8u_C1R, src_data, (int)src_step, + dst_data, (int)dst_step, roi, pMetrics) >= 0) + { + return CV_HAL_ERROR_OK; + } + return CV_HAL_ERROR_NOT_IMPLEMENTED; + } + + // All remaining paths produce a 32-bit float distance map. + if (dst_type != CV_32F) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + if (mask_size == cv::DIST_MASK_PRECISE) + { + // 4097 can't square into a float. +#if IPP_DISABLE_PERF_TRUE_DIST_MT + if (!((cv::getNumThreads() <= 1 || ((size_t)width * height < (size_t)(1 << 14))) && + height < 4097 && width < 4097)) + { + return CV_HAL_ERROR_NOT_IMPLEMENTED; + } +#endif + + int bufSize = 0; + if (ippiTrueDistanceTransformGetBufferSize_8u32f_C1R(roi, &bufSize) < 0) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + Ipp8u *pBuffer = (Ipp8u *)IPP_HAL_MALLOC(bufSize); + if (!pBuffer) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + IppStatus status = CV_INSTRUMENT_FUN_IPP(ippiTrueDistanceTransform_8u32f_C1R, src_data, (int)src_step, + (Ipp32f *)dst_data, (int)dst_step, roi, pBuffer); + ippFree(pBuffer); + if (status < 0) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + // https://github.com/opencv/opencv/issues/24082 + // There is probably a rounding issue that leads to non-deterministic behavior + // between runs on positions closer to zeros by x-axis in straight direction. + // As a workaround, we detect the distances that expected to be exact + // number of pixels and round manually. + static const float correctionDiff = 1.0f / (1 << 11); + for (int i = 0; i < height; ++i) + { + float* row = (float*)(dst_data + (size_t)i * dst_step); + for (int j = 0; j < width; ++j) + { + float rounded = static_cast(cvRound(row[j])); + if (std::fabs(row[j] - rounded) <= correctionDiff) + row[j] = rounded; + } + } + return CV_HAL_ERROR_OK; + } + + // DIST_MASK_3 / DIST_MASK_5 chamfer distances. + if (mask_size != cv::DIST_MASK_3 && mask_size != cv::DIST_MASK_5) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + // IPP uses 32-bit signed intermediates; bail out when the image is too large. + bool has_int_overflow = (int64)width * height >= INT_MAX; + if (has_int_overflow) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + float metrics[5] = {0}; + if (!ippGetDistanceTransformMask(dist_type, mask_size, metrics)) + return CV_HAL_ERROR_NOT_IMPLEMENTED; + + if (mask_size == cv::DIST_MASK_3) + { + if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_3x3_8u32f_C1R, src_data, (int)src_step, + (Ipp32f *)dst_data, (int)dst_step, roi, metrics) >= 0) + { + return CV_HAL_ERROR_OK; + } + } + else // DIST_MASK_5 + { + if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_5x5_8u32f_C1R, src_data, (int)src_step, + (Ipp32f *)dst_data, (int)dst_step, roi, metrics) >= 0) + { + return CV_HAL_ERROR_OK; + } + } + + return CV_HAL_ERROR_NOT_IMPLEMENTED; +} + +#endif // IPP_VERSION_X100 >= 700 diff --git a/modules/imgproc/src/distransform.cpp b/modules/imgproc/src/distransform.cpp index 3885bc5320..954a1c5a4a 100644 --- a/modules/imgproc/src/distransform.cpp +++ b/modules/imgproc/src/distransform.cpp @@ -40,6 +40,7 @@ // //M*/ #include "precomp.hpp" +#include "hal_replacement.hpp" namespace cv { @@ -1004,19 +1005,8 @@ static void distanceTransform_L1_8U(InputArray _src, OutputArray _dst) _dst.create( src.size(), CV_8UC1); Mat dst = _dst.getMat(); -#ifdef HAVE_IPP - CV_IPP_CHECK() - { - IppiSize roi = { src.cols, src.rows }; - Ipp32s pMetrics[2] = { 1, 2 }; //L1, 3x3 mask - if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_3x3_8u_C1R, src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, pMetrics) >= 0) - { - CV_IMPL_ADD(CV_IMPL_IPP); - return; - } - setIppErrorStatus(); - } -#endif + CALL_HAL(distanceTransform, cv_hal_distanceTransform, src.ptr(), src.step, dst.ptr(), dst.step, + src.cols, src.rows, CV_8U, cv::DIST_L1, cv::DIST_MASK_3); distanceATS_L1_8u(src, dst); } @@ -1055,53 +1045,8 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe if( maskSize == cv::DIST_MASK_PRECISE ) { - -#ifdef HAVE_IPP - CV_IPP_CHECK() - { -#if IPP_DISABLE_PERF_TRUE_DIST_MT - // IPP uses floats, but 4097 cannot be squared into a float - if((cv::getNumThreads()<=1 || (src.total()<(int)(1<<14))) && - src.rows < 4097 && src.cols < 4097) -#endif - { - IppStatus status; - IppiSize roi = { src.cols, src.rows }; - Ipp8u *pBuffer; - int bufSize=0; - - status = ippiTrueDistanceTransformGetBufferSize_8u32f_C1R(roi, &bufSize); - if (status>=0) - { - pBuffer = (Ipp8u *)CV_IPP_MALLOC( bufSize ); - status = CV_INSTRUMENT_FUN_IPP(ippiTrueDistanceTransform_8u32f_C1R, src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, pBuffer); - ippFree( pBuffer ); - if (status>=0) - { - // https://github.com/opencv/opencv/issues/24082 - // There is probably a rounding issue that leads to non-deterministic behavior - // between runs on positions closer to zeros by x-axis in straight direction. - // As a workaround, we detect the distances that expected to be exact - // number of pixels and round manually. - static const float correctionDiff = 1.0f / (1 << 11); - for (int i = 0; i < dst.rows; ++i) - { - float* row = dst.ptr(i); - for (int j = 0; j < dst.cols; ++j) - { - float rounded = static_cast(cvRound(row[j])); - if (fabs(row[j] - rounded) <= correctionDiff) - row[j] = rounded; - } - } - CV_IMPL_ADD(CV_IMPL_IPP); - return; - } - setIppErrorStatus(); - } - } - } -#endif + CALL_HAL(distanceTransform, cv_hal_distanceTransform, src.ptr(), src.step, dst.ptr(), dst.step, + src.cols, src.rows, CV_32F, distType, cv::DIST_MASK_PRECISE); trueDistTrans( src, dst ); return; @@ -1121,38 +1066,16 @@ void cv::distanceTransform( InputArray _src, OutputArray _dst, OutputArray _labe { if( maskSize == cv::DIST_MASK_3 ) { -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 700) - bool has_int_overflow = (int64)src.cols * src.rows >= INT_MAX; - if (!has_int_overflow && CV_IPP_CHECK_COND) - { - IppiSize roi = { src.cols, src.rows }; - if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_3x3_8u32f_C1R, src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, _mask) >= 0) - { - CV_IMPL_ADD(CV_IMPL_IPP); - return; - } - setIppErrorStatus(); - } -#endif + CALL_HAL(distanceTransform, cv_hal_distanceTransform, src.ptr(), src.step, dst.ptr(), dst.step, + src.cols, src.rows, CV_32F, distType, cv::DIST_MASK_3); temp.create(size.height + border*2, size.width + border*2, CV_32SC1); distanceTransform_3x3(src, temp, dst, _mask); } else { -#if defined (HAVE_IPP) && (IPP_VERSION_X100 >= 700) - bool has_int_overflow = (int64)src.cols * src.rows >= INT_MAX; - if (!has_int_overflow && CV_IPP_CHECK_COND) - { - IppiSize roi = { src.cols, src.rows }; - if (CV_INSTRUMENT_FUN_IPP(ippiDistanceTransform_5x5_8u32f_C1R, src.ptr(), (int)src.step, dst.ptr(), (int)dst.step, roi, _mask) >= 0) - { - CV_IMPL_ADD(CV_IMPL_IPP); - return; - } - setIppErrorStatus(); - } -#endif + CALL_HAL(distanceTransform, cv_hal_distanceTransform, src.ptr(), src.step, dst.ptr(), dst.step, + src.cols, src.rows, CV_32F, distType, cv::DIST_MASK_5); temp.create(size.height + border*2, size.width + border*2, CV_32SC1); distanceTransform_5x5(src, temp, dst, _mask); diff --git a/modules/imgproc/src/hal_replacement.hpp b/modules/imgproc/src/hal_replacement.hpp index 6a869e0a9a..ca6ce6acd8 100644 --- a/modules/imgproc/src/hal_replacement.hpp +++ b/modules/imgproc/src/hal_replacement.hpp @@ -1241,6 +1241,24 @@ inline int hal_ni_threshold_otsu(const uchar* src_data, size_t src_step, uchar* #define cv_hal_threshold_otsu hal_ni_threshold_otsu //! @endcond +/** + @brief Calculates the distance to the closest zero pixel for each pixel of the source image + @param src_data Source image (8-bit single-channel) data + @param src_step Source image step + @param dst_data Destination image data + @param dst_step Destination image step + @param width Source image width + @param height Source image height + @param dst_type Type of the destination image (CV_8UC1 or CV_32FC1) + @param dist_type Type of distance (cv::DistanceTypes: DIST_L1, DIST_L2, DIST_C) + @param mask_size Size of the distance transform mask (cv::DistanceTransformMasks: DIST_MASK_3, DIST_MASK_5, DIST_MASK_PRECISE) +*/ +inline int hal_ni_distanceTransform(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int width, int height, int dst_type, int dist_type, int mask_size) { return CV_HAL_ERROR_NOT_IMPLEMENTED; } + +//! @cond IGNORED +#define cv_hal_distanceTransform hal_ni_distanceTransform +//! @endcond + /** @brief Calculate box filter @param src_data Source image data