diff --git a/3rdparty/hal_rvv/hal_rvv.hpp b/3rdparty/hal_rvv/hal_rvv.hpp index e86c974574..c18d7949ce 100644 --- a/3rdparty/hal_rvv/hal_rvv.hpp +++ b/3rdparty/hal_rvv/hal_rvv.hpp @@ -57,6 +57,7 @@ #include "hal_rvv_1p0/thresh.hpp" // imgproc #include "hal_rvv_1p0/histogram.hpp" // imgproc #include "hal_rvv_1p0/resize.hpp" // imgproc +#include "hal_rvv_1p0/integral.hpp" // imgproc #endif #endif diff --git a/3rdparty/hal_rvv/hal_rvv_1p0/integral.hpp b/3rdparty/hal_rvv/hal_rvv_1p0/integral.hpp new file mode 100644 index 0000000000..a3ea0b5557 --- /dev/null +++ b/3rdparty/hal_rvv/hal_rvv_1p0/integral.hpp @@ -0,0 +1,173 @@ +// This file is part of OpenCV project. +// It is subject to the license terms in the LICENSE file found in the top-level directory +// of this distribution and at http://opencv.org/license.html. + +// Copyright (C) 2025, Institute of Software, Chinese Academy of Sciences. + +#ifndef OPENCV_HAL_RVV_INTEGRAL_HPP_INCLUDED +#define OPENCV_HAL_RVV_INTEGRAL_HPP_INCLUDED + +#include +#include "types.hpp" + +namespace cv { namespace cv_hal_rvv { + +#undef cv_hal_integral +#define cv_hal_integral cv::cv_hal_rvv::integral + +template +inline typename vec_t::VecType repeat_last_n(typename vec_t::VecType vs, int n, size_t vl) { + auto v_last = vec_t::vslidedown(vs, vl - n, vl); + if (n == 1) return vec_t::vmv(vec_t::vmv_x(v_last), vl); + for (size_t offset = n; offset < vl; offset <<= 1) { + v_last = vec_t::vslideup(v_last, v_last, offset, vl); + } + return v_last; +} + +template +inline int integral_inner(const uchar* src_data, size_t src_step, + uchar* sum_data, size_t sum_step, + int width, int height, int cn) { + using data_t = typename data_vec_t::ElemType; + using acc_t = typename acc_vec_t::ElemType; + + for (int y = 0; y < height; y++) { + const data_t* src = reinterpret_cast(src_data + src_step * y); + acc_t* prev = reinterpret_cast(sum_data + sum_step * y); + acc_t* curr = reinterpret_cast(sum_data + sum_step * (y + 1)); + memset(curr, 0, cn * sizeof(acc_t)); + + size_t vl = acc_vec_t::setvlmax(); + auto sum = acc_vec_t::vmv(0, vl); + for (size_t x = 0; x < static_cast(width); x += vl) { + vl = acc_vec_t::setvl(width - x); + __builtin_prefetch(&src[x + vl], 0); + __builtin_prefetch(&prev[x + cn], 0); + + auto v_src = data_vec_t::vload(&src[x], vl); + auto acc = acc_vec_t::cast(v_src, vl); + + if (sqsum) { // Squared Sum + acc = acc_vec_t::vmul(acc, acc, vl); + } + + auto v_zero = acc_vec_t::vmv(0, vl); + for (size_t offset = cn; offset < vl; offset <<= 1) { + auto v_shift = acc_vec_t::vslideup(v_zero, acc, offset, vl); + acc = acc_vec_t::vadd(acc, v_shift, vl); + } + auto last_n = repeat_last_n(acc, cn, vl); + + auto v_prev = acc_vec_t::vload(&prev[x + cn], vl); + acc = acc_vec_t::vadd(acc, v_prev, vl); + acc = acc_vec_t::vadd(acc, sum, vl); + sum = acc_vec_t::vadd(sum, last_n, vl); + + acc_vec_t::vstore(&curr[x + cn], acc, vl); + } + } + + return CV_HAL_ERROR_OK; +} + +template +inline int integral(const uchar* src_data, size_t src_step, uchar* sum_data, size_t sum_step, uchar* sqsum_data, size_t sqsum_step, int width, int height, int cn) { + memset(sum_data, 0, (sum_step) * sizeof(uchar)); + + int result = CV_HAL_ERROR_NOT_IMPLEMENTED; + if (sqsum_data == nullptr) { + result = integral_inner(src_data, src_step, sum_data, sum_step, width, height, cn); + } else { + result = integral_inner(src_data, src_step, sum_data, sum_step, width, height, cn); + memset(sqsum_data, 0, (sqsum_step) * sizeof(uchar)); + if (result != CV_HAL_ERROR_OK) return result; + result = integral_inner(src_data, src_step, sqsum_data, sqsum_step, width, height, cn); + } + return result; +} + +/** + @brief Calculate integral image + @param depth Depth of source image + @param sdepth Depth of sum image + @param sqdepth Depth of square sum image + @param src_data Source image data + @param src_step Source image step + @param sum_data Sum image data + @param sum_step Sum image step + @param sqsum_data Square sum image data + @param sqsum_step Square sum image step + @param tilted_data Tilted sum image data + @param tilted_step Tilted sum image step + @param width Source image width + @param height Source image height + @param cn Number of channels + @note Following combinations of image depths are used: + Source | Sum | Square sum + -------|-----|----------- + CV_8U | CV_32S | CV_64F + CV_8U | CV_32S | CV_32F + CV_8U | CV_32S | CV_32S + CV_8U | CV_32F | CV_64F + CV_8U | CV_32F | CV_32F + CV_8U | CV_64F | CV_64F + CV_16U | CV_64F | CV_64F + CV_16S | CV_64F | CV_64F + CV_32F | CV_32F | CV_64F + CV_32F | CV_32F | CV_32F + CV_32F | CV_64F | CV_64F + CV_64F | CV_64F | CV_64F +*/ +inline int integral(int depth, int sdepth, int sqdepth, + const uchar* src_data, size_t src_step, + uchar* sum_data, size_t sum_step, + uchar* sqsum_data, size_t sqsum_step, + uchar* tilted_data, [[maybe_unused]] size_t tilted_step, + int width, int height, int cn) { + // tilted sum and cn == 3 cases are not supported + if (tilted_data || cn == 3) { + return CV_HAL_ERROR_NOT_IMPLEMENTED; + } + + // Skip images that are too small + if (!(width >> 8 || height >> 8)) { + return CV_HAL_ERROR_NOT_IMPLEMENTED; + } + + int result = CV_HAL_ERROR_NOT_IMPLEMENTED; + + width *= cn; + + if( depth == CV_8U && sdepth == CV_32S && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_8U && sdepth == CV_32S && sqdepth == CV_32F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_8U && sdepth == CV_32S && sqdepth == CV_32S ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_8U && sdepth == CV_32F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_8U && sdepth == CV_32F && sqdepth == CV_32F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_8U && sdepth == CV_64F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_16U && sdepth == CV_64F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_16S && sdepth == CV_64F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_32F && sdepth == CV_32F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_32F && sdepth == CV_32F && sqdepth == CV_32F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_32F && sdepth == CV_64F && sqdepth == CV_64F ) + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + else if( depth == CV_64F && sdepth == CV_64F && sqdepth == CV_64F ) { + result = integral, RVV, RVV>(src_data, src_step, sum_data, sum_step, sqsum_data, sqsum_step, width, height, cn); + } + + return result; +} + +}} + +#endif diff --git a/3rdparty/hal_rvv/hal_rvv_1p0/types.hpp b/3rdparty/hal_rvv/hal_rvv_1p0/types.hpp index 8c8ad23787..6613a018fc 100644 --- a/3rdparty/hal_rvv/hal_rvv_1p0/types.hpp +++ b/3rdparty/hal_rvv/hal_rvv_1p0/types.hpp @@ -153,6 +153,12 @@ static inline VecType vmv(ElemType a, size_t vl) { static inline VecType vmv_s(ElemType a, size_t vl) { \ return __riscv_v##IS_F##mv_s_##X_OR_F##_##TYPE##LMUL(a, vl); \ } \ +static inline VecType vslideup(VecType vs2, VecType vs1, size_t n, size_t vl) { \ + return __riscv_vslideup_vx_##TYPE##LMUL(vs2, vs1, n, vl); \ +} \ +static inline VecType vslidedown(VecType vs, size_t n, size_t vl) { \ + return __riscv_vslidedown_vx_##TYPE##LMUL(vs, n, vl); \ +} \ HAL_RVV_SIZE_RELATED_CUSTOM(EEW, TYPE, LMUL) #define HAL_RVV_SIZE_UNRELATED(S_OR_F, X_OR_F, IS_U, IS_F, IS_O) \ @@ -380,7 +386,7 @@ template <> struct RVV_ToFloatHelper<8> {using type = double;}; template <> \ inline ONE::VecType ONE::cast(TWO::VecType v, size_t vl) { return __riscv_vncvt_x(v, vl); } \ template <> \ - inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vwcvt_x(v, vl); } + inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vsext_vf2(v, vl); } HAL_RVV_CVT(RVV_I8M4, RVV_I16M8) HAL_RVV_CVT(RVV_I8M2, RVV_I16M4) @@ -406,7 +412,7 @@ HAL_RVV_CVT(RVV_I32MF2, RVV_I64M1) template <> \ inline ONE::VecType ONE::cast(TWO::VecType v, size_t vl) { return __riscv_vncvt_x(v, vl); } \ template <> \ - inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vwcvtu_x(v, vl); } + inline TWO::VecType TWO::cast(ONE::VecType v, size_t vl) { return __riscv_vzext_vf2(v, vl); } HAL_RVV_CVT(RVV_U8M4, RVV_U16M8) HAL_RVV_CVT(RVV_U8M2, RVV_U16M4) @@ -592,6 +598,277 @@ HAL_RVV_CVT( uint8_t, int8_t, u8, i8, LMUL_f8, mf8) #undef HAL_RVV_CVT +#define HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_TYPE, LMUL) \ + template <> \ + inline RVV::VecType RVV::cast(RVV::VecType v, [[maybe_unused]] size_t vl) { \ + return __riscv_vreinterpret_##A_TYPE##LMUL(v); \ + } \ + template <> \ + inline RVV::VecType RVV::cast(RVV::VecType v, [[maybe_unused]] size_t vl) { \ + return __riscv_vreinterpret_##B_TYPE##LMUL(v); \ + } + +#define HAL_RVV_CVT2(A, B, A_TYPE, B_TYPE) \ + HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_1, m1) \ + HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_2, m2) \ + HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_4, m4) \ + HAL_RVV_CVT(A, B, A_TYPE, B_TYPE, LMUL_8, m8) + +HAL_RVV_CVT2( uint8_t, int8_t, u8, i8) +HAL_RVV_CVT2(uint16_t, int16_t, u16, i16) +HAL_RVV_CVT2(uint32_t, int32_t, u32, i32) +HAL_RVV_CVT2(uint64_t, int64_t, u64, i64) + +#undef HAL_RVV_CVT2 +#undef HAL_RVV_CVT + +#define HAL_RVV_CVT(FROM, INTERMEDIATE, TO) \ + template <> \ + inline TO::VecType TO::cast(FROM::VecType v, size_t vl) { \ + return TO::cast(INTERMEDIATE::cast(v, vl), vl); \ + } \ + template <> \ + inline FROM::VecType FROM::cast(TO::VecType v, size_t vl) { \ + return FROM::cast(INTERMEDIATE::cast(v, vl), vl); \ + } + +// Integer and Float conversions +HAL_RVV_CVT(RVV_I8M1, RVV_I32M4, RVV_F32M4) +HAL_RVV_CVT(RVV_I8M2, RVV_I32M8, RVV_F32M8) +HAL_RVV_CVT(RVV_I8M1, RVV_I64M8, RVV_F64M8) + +HAL_RVV_CVT(RVV_I16M1, RVV_I32M2, RVV_F32M2) +HAL_RVV_CVT(RVV_I16M2, RVV_I32M4, RVV_F32M4) +HAL_RVV_CVT(RVV_I16M4, RVV_I32M8, RVV_F32M8) +HAL_RVV_CVT(RVV_I16M1, RVV_I64M4, RVV_F64M4) +HAL_RVV_CVT(RVV_I16M2, RVV_I64M8, RVV_F64M8) + +HAL_RVV_CVT(RVV_I32M1, RVV_I64M2, RVV_F64M2) +HAL_RVV_CVT(RVV_I32M2, RVV_I64M4, RVV_F64M4) +HAL_RVV_CVT(RVV_I32M4, RVV_I64M8, RVV_F64M8) + +HAL_RVV_CVT(RVV_U8M1, RVV_U32M4, RVV_F32M4) +HAL_RVV_CVT(RVV_U8M2, RVV_U32M8, RVV_F32M8) +HAL_RVV_CVT(RVV_U8M1, RVV_U64M8, RVV_F64M8) + +HAL_RVV_CVT(RVV_U16M1, RVV_U32M2, RVV_F32M2) +HAL_RVV_CVT(RVV_U16M2, RVV_U32M4, RVV_F32M4) +HAL_RVV_CVT(RVV_U16M4, RVV_U32M8, RVV_F32M8) +HAL_RVV_CVT(RVV_U16M1, RVV_U64M4, RVV_F64M4) +HAL_RVV_CVT(RVV_U16M2, RVV_U64M8, RVV_F64M8) + +HAL_RVV_CVT(RVV_U32M1, RVV_U64M2, RVV_F64M2) +HAL_RVV_CVT(RVV_U32M2, RVV_U64M4, RVV_F64M4) +HAL_RVV_CVT(RVV_U32M4, RVV_U64M8, RVV_F64M8) + +// Signed and Unsigned conversions +HAL_RVV_CVT(RVV_U8M1, RVV_U16M2, RVV_I16M2) +HAL_RVV_CVT(RVV_U8M2, RVV_U16M4, RVV_I16M4) +HAL_RVV_CVT(RVV_U8M4, RVV_U16M8, RVV_I16M8) + +HAL_RVV_CVT(RVV_U8M1, RVV_U32M4, RVV_I32M4) +HAL_RVV_CVT(RVV_U8M2, RVV_U32M8, RVV_I32M8) + +HAL_RVV_CVT(RVV_U8M1, RVV_U64M8, RVV_I64M8) + +#undef HAL_RVV_CVT + +// ---------------------------- Define Register Group Operations ------------------------------- + +#if defined(__clang__) && __clang_major__ <= 17 +#define HAL_RVV_GROUP(ONE, TWO, TYPE, ONE_LMUL, TWO_LMUL) \ + template \ + inline ONE::VecType vget(TWO::VecType v) { \ + return __riscv_vget_v_##TYPE##TWO_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(TWO::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, idx, val); \ + } \ + inline TWO::VecType vcreate(ONE::VecType v0, ONE::VecType v1) { \ + TWO::VecType v{}; \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, 0, v0); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, 1, v1); \ + return v; \ + } +#else +#define HAL_RVV_GROUP(ONE, TWO, TYPE, ONE_LMUL, TWO_LMUL) \ + template \ + inline ONE::VecType vget(TWO::VecType v) { \ + return __riscv_vget_v_##TYPE##TWO_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(TWO::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v, idx, val); \ + } \ + inline TWO::VecType vcreate(ONE::VecType v0, ONE::VecType v1) { \ + return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##TWO_LMUL(v0, v1); \ + } +#endif + +HAL_RVV_GROUP(RVV_I8M1, RVV_I8M2, i8, m1, m2) +HAL_RVV_GROUP(RVV_I8M2, RVV_I8M4, i8, m2, m4) +HAL_RVV_GROUP(RVV_I8M4, RVV_I8M8, i8, m4, m8) + +HAL_RVV_GROUP(RVV_I16M1, RVV_I16M2, i16, m1, m2) +HAL_RVV_GROUP(RVV_I16M2, RVV_I16M4, i16, m2, m4) +HAL_RVV_GROUP(RVV_I16M4, RVV_I16M8, i16, m4, m8) + +HAL_RVV_GROUP(RVV_I32M1, RVV_I32M2, i32, m1, m2) +HAL_RVV_GROUP(RVV_I32M2, RVV_I32M4, i32, m2, m4) +HAL_RVV_GROUP(RVV_I32M4, RVV_I32M8, i32, m4, m8) + +HAL_RVV_GROUP(RVV_I64M1, RVV_I64M2, i64, m1, m2) +HAL_RVV_GROUP(RVV_I64M2, RVV_I64M4, i64, m2, m4) +HAL_RVV_GROUP(RVV_I64M4, RVV_I64M8, i64, m4, m8) + +HAL_RVV_GROUP(RVV_U8M1, RVV_U8M2, u8, m1, m2) +HAL_RVV_GROUP(RVV_U8M2, RVV_U8M4, u8, m2, m4) +HAL_RVV_GROUP(RVV_U8M4, RVV_U8M8, u8, m4, m8) + +HAL_RVV_GROUP(RVV_U16M1, RVV_U16M2, u16, m1, m2) +HAL_RVV_GROUP(RVV_U16M2, RVV_U16M4, u16, m2, m4) +HAL_RVV_GROUP(RVV_U16M4, RVV_U16M8, u16, m4, m8) + +HAL_RVV_GROUP(RVV_U32M1, RVV_U32M2, u32, m1, m2) +HAL_RVV_GROUP(RVV_U32M2, RVV_U32M4, u32, m2, m4) +HAL_RVV_GROUP(RVV_U32M4, RVV_U32M8, u32, m4, m8) + +HAL_RVV_GROUP(RVV_U64M1, RVV_U64M2, u64, m1, m2) +HAL_RVV_GROUP(RVV_U64M2, RVV_U64M4, u64, m2, m4) +HAL_RVV_GROUP(RVV_U64M4, RVV_U64M8, u64, m4, m8) + +HAL_RVV_GROUP(RVV_F32M1, RVV_F32M2, f32, m1, m2) +HAL_RVV_GROUP(RVV_F32M2, RVV_F32M4, f32, m2, m4) +HAL_RVV_GROUP(RVV_F32M4, RVV_F32M8, f32, m4, m8) + +HAL_RVV_GROUP(RVV_F64M1, RVV_F64M2, f64, m1, m2) +HAL_RVV_GROUP(RVV_F64M2, RVV_F64M4, f64, m2, m4) +HAL_RVV_GROUP(RVV_F64M4, RVV_F64M8, f64, m4, m8) + +#undef HAL_RVV_GROUP + +#if defined(__clang__) && __clang_major__ <= 17 +#define HAL_RVV_GROUP(ONE, FOUR, TYPE, ONE_LMUL, FOUR_LMUL) \ + template \ + inline ONE::VecType vget(FOUR::VecType v) { \ + return __riscv_vget_v_##TYPE##FOUR_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(FOUR::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, idx, val); \ + } \ + inline FOUR::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3) { \ + FOUR::VecType v{}; \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 0, v0); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 1, v1); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 2, v2); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, 3, v3); \ + return v; \ + } +#else +#define HAL_RVV_GROUP(ONE, FOUR, TYPE, ONE_LMUL, FOUR_LMUL) \ + template \ + inline ONE::VecType vget(FOUR::VecType v) { \ + return __riscv_vget_v_##TYPE##FOUR_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(FOUR::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v, idx, val); \ + } \ + inline FOUR::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3) { \ + return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##FOUR_LMUL(v0, v1, v2, v3); \ + } +#endif + +HAL_RVV_GROUP(RVV_I8M1, RVV_I8M4, i8, m1, m4) +HAL_RVV_GROUP(RVV_I8M2, RVV_I8M8, i8, m2, m8) + +HAL_RVV_GROUP(RVV_U8M1, RVV_U8M4, u8, m1, m4) +HAL_RVV_GROUP(RVV_U8M2, RVV_U8M8, u8, m2, m8) + +HAL_RVV_GROUP(RVV_I16M1, RVV_I16M4, i16, m1, m4) +HAL_RVV_GROUP(RVV_I16M2, RVV_I16M8, i16, m2, m8) + +HAL_RVV_GROUP(RVV_U16M1, RVV_U16M4, u16, m1, m4) +HAL_RVV_GROUP(RVV_U16M2, RVV_U16M8, u16, m2, m8) + +HAL_RVV_GROUP(RVV_I32M1, RVV_I32M4, i32, m1, m4) +HAL_RVV_GROUP(RVV_I32M2, RVV_I32M8, i32, m2, m8) + +HAL_RVV_GROUP(RVV_U32M1, RVV_U32M4, u32, m1, m4) +HAL_RVV_GROUP(RVV_U32M2, RVV_U32M8, u32, m2, m8) + +HAL_RVV_GROUP(RVV_I64M1, RVV_I64M4, i64, m1, m4) +HAL_RVV_GROUP(RVV_I64M2, RVV_I64M8, i64, m2, m8) + +HAL_RVV_GROUP(RVV_U64M1, RVV_U64M4, u64, m1, m4) +HAL_RVV_GROUP(RVV_U64M2, RVV_U64M8, u64, m2, m8) + +HAL_RVV_GROUP(RVV_F32M1, RVV_F32M4, f32, m1, m4) +HAL_RVV_GROUP(RVV_F32M2, RVV_F32M8, f32, m2, m8) + +HAL_RVV_GROUP(RVV_F64M1, RVV_F64M4, f64, m1, m4) +HAL_RVV_GROUP(RVV_F64M2, RVV_F64M8, f64, m2, m8) + +#undef HAL_RVV_GROUP + +#if defined(__clang__) && __clang_major__ <= 17 +#define HAL_RVV_GROUP(ONE, EIGHT, TYPE, ONE_LMUL, EIGHT_LMUL) \ + template \ + inline ONE::VecType vget(EIGHT::VecType v) { \ + return __riscv_vget_v_##TYPE##EIGHT_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(EIGHT::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, idx, val); \ + } \ + inline EIGHT::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3, \ + ONE::VecType v4, ONE::VecType v5, ONE::VecType v6, ONE::VecType v7) { \ + EIGHT::VecType v{}; \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 0, v0); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 1, v1); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 2, v2); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 3, v3); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 4, v4); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 5, v5); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 6, v6); \ + v = __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, 7, v7); \ + return v; \ + } +#else +#define HAL_RVV_GROUP(ONE, EIGHT, TYPE, ONE_LMUL, EIGHT_LMUL) \ + template \ + inline ONE::VecType vget(EIGHT::VecType v) { \ + return __riscv_vget_v_##TYPE##EIGHT_LMUL##_##TYPE##ONE_LMUL(v, idx); \ + } \ + template \ + inline void vset(EIGHT::VecType v, ONE::VecType val) { \ + __riscv_vset_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v, idx, val); \ + } \ + inline EIGHT::VecType vcreate(ONE::VecType v0, ONE::VecType v1, ONE::VecType v2, ONE::VecType v3, \ + ONE::VecType v4, ONE::VecType v5, ONE::VecType v6, ONE::VecType v7) { \ + return __riscv_vcreate_v_##TYPE##ONE_LMUL##_##TYPE##EIGHT_LMUL(v0, v1, v2, v3, v4, v5, v6, v7); \ + } +#endif + +HAL_RVV_GROUP(RVV_I8M1, RVV_I8M8, i8, m1, m8) +HAL_RVV_GROUP(RVV_U8M1, RVV_U8M8, u8, m1, m8) + +HAL_RVV_GROUP(RVV_I16M1, RVV_I16M8, i16, m1, m8) +HAL_RVV_GROUP(RVV_U16M1, RVV_U16M8, u16, m1, m8) + +HAL_RVV_GROUP(RVV_I32M1, RVV_I32M8, i32, m1, m8) +HAL_RVV_GROUP(RVV_U32M1, RVV_U32M8, u32, m1, m8) + +HAL_RVV_GROUP(RVV_I64M1, RVV_I64M8, i64, m1, m8) +HAL_RVV_GROUP(RVV_U64M1, RVV_U64M8, u64, m1, m8) + +HAL_RVV_GROUP(RVV_F32M1, RVV_F32M8, f32, m1, m8) +HAL_RVV_GROUP(RVV_F64M1, RVV_F64M8, f64, m1, m8) + +#undef HAL_RVV_GROUP + }} // namespace cv::cv_hal_rvv #endif //OPENCV_HAL_RVV_TYPES_HPP_INCLUDED diff --git a/modules/imgproc/perf/perf_integral.cpp b/modules/imgproc/perf/perf_integral.cpp index 0a4fc49329..23ab10b57f 100644 --- a/modules/imgproc/perf/perf_integral.cpp +++ b/modules/imgproc/perf/perf_integral.cpp @@ -20,7 +20,7 @@ static int extraOutputDepths[6][2] = {{CV_32S, CV_32S}, {CV_32S, CV_32F}, {CV_32 typedef tuple Size_MatType_OutMatDepth_t; typedef perf::TestBaseWithParam Size_MatType_OutMatDepth; -typedef tuple Size_MatType_OutMatDepthArray_t; +typedef tuple> Size_MatType_OutMatDepthArray_t; typedef perf::TestBaseWithParam Size_MatType_OutMatDepthArray; PERF_TEST_P(Size_MatType_OutMatDepth, integral, @@ -83,19 +83,42 @@ PERF_TEST_P(Size_MatType_OutMatDepth, integral_sqsum, SANITY_CHECK(sqsum, 1e-6); } +static std::vector> GetFullSqsumDepthPairs() { + static int extraDepths[12][2] = { + {CV_8U, DEPTH_32S_64F}, + {CV_8U, DEPTH_32S_32F}, + {CV_8U, DEPTH_32S_32S}, + {CV_8U, DEPTH_32F_64F}, + {CV_8U, DEPTH_32F_32F}, + {CV_8U, DEPTH_64F_64F}, + {CV_16U, DEPTH_64F_64F}, + {CV_16S, DEPTH_64F_64F}, + {CV_32F, DEPTH_32F_64F}, + {CV_32F, DEPTH_32F_32F}, + {CV_32F, DEPTH_64F_64F}, + {CV_64F, DEPTH_64F_64F} + }; + std::vector> valid_pairs; + for (size_t i = 0; i < 12; i++) { + for (int cn = 1; cn <= 4; cn++) { + valid_pairs.emplace_back(CV_MAKETYPE(extraDepths[i][0], cn), extraDepths[i][1]); + } + } + return valid_pairs; +} + PERF_TEST_P(Size_MatType_OutMatDepthArray, DISABLED_integral_sqsum_full, testing::Combine( testing::Values(TYPICAL_MAT_SIZES), - testing::Values(CV_8UC1, CV_8UC2, CV_8UC3, CV_8UC4), - testing::Values(DEPTH_32S_32S, DEPTH_32S_32F, DEPTH_32S_64F, DEPTH_32F_32F, DEPTH_32F_64F, DEPTH_64F_64F) + testing::ValuesIn(GetFullSqsumDepthPairs()) ) ) { Size sz = get<0>(GetParam()); - int matType = get<1>(GetParam()); - int *outputDepths = (int *)extraOutputDepths[get<2>(GetParam())]; - int sdepth = outputDepths[0]; - int sqdepth = outputDepths[1]; + auto depths = get<1>(GetParam()); + int matType = get<0>(depths); + int sdepth = extraOutputDepths[get<1>(depths)][0]; + int sqdepth = extraOutputDepths[get<1>(depths)][1]; Mat src(sz, matType); Mat sum(sz, sdepth); diff --git a/modules/imgproc/src/sumpixels.dispatch.cpp b/modules/imgproc/src/sumpixels.dispatch.cpp index b828ec70c0..dc000df6eb 100644 --- a/modules/imgproc/src/sumpixels.dispatch.cpp +++ b/modules/imgproc/src/sumpixels.dispatch.cpp @@ -486,7 +486,8 @@ cvIntegral( const CvArr* image, CvArr* sumImage, ptilted = &tilted; } cv::integral( src, sum, psqsum ? cv::_OutputArray(*psqsum) : cv::_OutputArray(), - ptilted ? cv::_OutputArray(*ptilted) : cv::_OutputArray(), sum.depth() ); + ptilted ? cv::_OutputArray(*ptilted) : cv::_OutputArray(), sum.depth(), + psqsum ? psqsum->depth() : -1 ); CV_Assert( sum.data == sum0.data && sqsum.data == sqsum0.data && tilted.data == tilted0.data ); } diff --git a/modules/imgproc/test/test_filter.cpp b/modules/imgproc/test/test_filter.cpp index 685743630f..46164aed21 100644 --- a/modules/imgproc/test/test_filter.cpp +++ b/modules/imgproc/test/test_filter.cpp @@ -1684,19 +1684,34 @@ void CV_IntegralTest::get_test_array_types_and_sizes( int test_case_idx, vector >& sizes, vector >& types ) { RNG& rng = ts->get_rng(); - int depth = cvtest::randInt(rng) % 2, sum_depth; int cn = cvtest::randInt(rng) % 4 + 1; cvtest::ArrayTest::get_test_array_types_and_sizes( test_case_idx, sizes, types ); Size sum_size; - depth = depth == 0 ? CV_8U : CV_32F; - int b = (cvtest::randInt(rng) & 1) != 0; - sum_depth = depth == CV_8U && b ? CV_32S : b ? CV_32F : CV_64F; + const int depths[12][3] = { + {CV_8U, CV_32S, CV_64F}, + {CV_8U, CV_32S, CV_32F}, + {CV_8U, CV_32S, CV_32S}, + {CV_8U, CV_32F, CV_64F}, + {CV_8U, CV_32F, CV_32F}, + {CV_8U, CV_64F, CV_64F}, + {CV_16U, CV_64F, CV_64F}, + {CV_16S, CV_64F, CV_64F}, + {CV_32F, CV_32F, CV_64F}, + {CV_32F, CV_32F, CV_32F}, + {CV_32F, CV_64F, CV_64F}, + {CV_64F, CV_64F, CV_64F}, + }; - types[INPUT][0] = CV_MAKETYPE(depth,cn); + int random_choice = cvtest::randInt(rng) % 12; + int depth = depths[random_choice][0]; + int sum_depth = depths[random_choice][1]; + int sqsum_depth = depths[random_choice][2]; + + types[INPUT][0] = CV_MAKETYPE(depth, cn); types[OUTPUT][0] = types[REF_OUTPUT][0] = types[OUTPUT][2] = types[REF_OUTPUT][2] = CV_MAKETYPE(sum_depth, cn); - types[OUTPUT][1] = types[REF_OUTPUT][1] = CV_MAKETYPE(CV_64F, cn); + types[OUTPUT][1] = types[REF_OUTPUT][1] = CV_MAKETYPE(sqsum_depth, cn); sum_size.width = sizes[INPUT][0].width + 1; sum_size.height = sizes[INPUT][0].height + 1; @@ -1738,7 +1753,7 @@ void CV_IntegralTest::run_func() static void test_integral( const Mat& img, Mat* sum, Mat* sqsum, Mat* tilted ) { - CV_Assert( img.depth() == CV_32F ); + CV_Assert( img.depth() == CV_64F ); sum->create(img.rows+1, img.cols+1, CV_64F); if( sqsum ) @@ -1746,7 +1761,7 @@ static void test_integral( const Mat& img, Mat* sum, Mat* sqsum, Mat* tilted ) if( tilted ) tilted->create(img.rows+1, img.cols+1, CV_64F); - const float* data = img.ptr(); + const double* data = img.ptr(); double* sdata = sum->ptr(); double* sqdata = sqsum ? sqsum->ptr() : 0; double* tdata = tilted ? tilted->ptr() : 0; @@ -1788,7 +1803,7 @@ static void test_integral( const Mat& img, Mat* sum, Mat* sqsum, Mat* tilted ) else { ts += tdata[x-tstep-1]; - if( data > img.ptr() ) + if( data > img.ptr() ) { ts += data[x-step-1]; if( x < size.width ) @@ -1824,7 +1839,7 @@ void CV_IntegralTest::prepare_to_validation( int /*test_case_idx*/ ) { if( cn > 1 ) cvtest::extract(src, plane, i); - plane.convertTo(srcf, CV_32F); + plane.convertTo(srcf, CV_64F); test_integral( srcf, &psum, sqsum0 ? &psqsum : 0, tsum0 ? &ptsum : 0 ); psum.convertTo(psum2, sum0->depth());