Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Draft: core: Extend norm() function for u64/s64/u32 #24888

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
wants to merge 2 commits into from
Closed

Draft: core: Extend norm() function for u64/s64/u32 #24888

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
b01ece4
core: support norm() function for u64/s64/u32
Kumataro Jan 19, 2024
792db9c
fix for C4244
Kumataro Jan 19, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 7 additions & 2 deletions modules/core/include/opencv2/core/base.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -399,6 +399,8 @@ inline int cv_abs(uchar x) { return x; }
inline int cv_abs(schar x) { return std::abs(x); }
inline int cv_abs(ushort x) { return x; }
inline int cv_abs(short x) { return std::abs(x); }
inline uint32_t cv_abs(uint32_t x) { return x; }
inline uint64_t cv_abs(uint64_t x) { return x; }

template<typename _Tp, typename _AccTp> static inline
_AccTp normL2Sqr(const _Tp* a, int n)
Expand All @@ -408,13 +410,16 @@ _AccTp normL2Sqr(const _Tp* a, int n)
#if CV_ENABLE_UNROLLED
for( ; i <= n - 4; i += 4 )
{
_AccTp v0 = a[i], v1 = a[i+1], v2 = a[i+2], v3 = a[i+3];
_AccTp v0 = static_cast<_AccTp>(a[i]);
_AccTp v1 = static_cast<_AccTp>(a[i+1]);
_AccTp v2 = static_cast<_AccTp>(a[i+2]);
_AccTp v3 = static_cast<_AccTp>(a[i+3]);
s += v0*v0 + v1*v1 + v2*v2 + v3*v3;
}
#endif
for( ; i < n; i++ )
{
_AccTp v = a[i];
_AccTp v = static_cast<_AccTp>(a[i]);
s += v*v;
}
return s;
Expand Down
3 changes: 3 additions & 0 deletions modules/core/include/opencv2/core/mat.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -299,6 +299,9 @@ class CV_EXPORTS _OutputArray : public _InputArray
DEPTH_MASK_32F = 1 << CV_32F,
DEPTH_MASK_64F = 1 << CV_64F,
DEPTH_MASK_16F = 1 << CV_16F,
DEPTH_MASK_64U = 1 << CV_64U,
DEPTH_MASK_64S = 1 << CV_64S,
DEPTH_MASK_32U = 1 << CV_32U,
DEPTH_MASK_ALL = (1 << CV_DEPTH_CURR_MAX)-1,
DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
DEPTH_MASK_ALL_16F = DEPTH_MASK_ALL,
Expand Down
219 changes: 212 additions & 7 deletions modules/core/src/norm.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -295,6 +295,62 @@ normDiffInf_(const T* src1, const T* src2, const uchar* mask, ST* _result, int l
*_result = result;
return 0;
}
template<> int
normDiffInf_(const uint32_t* src1, const uint32_t* src2, const uchar* mask, uint32_t* _result, int len, int cn)
{
uint32_t result = *_result;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint32_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
result = std::max(result, v);
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
{
for( int k = 0; k < cn; k++ )
{
uint32_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
result = std::max(result, v);
}
}
}
*_result = result;
return 0;
}
template<> int
normDiffInf_(const uint64_t* src1, const uint64_t* src2, const uchar* mask, uint64_t* _result, int len, int cn)
{
uint64_t result = *_result;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
result = std::max(result, v);
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
{
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
result = std::max(result, v);
}
}
}
*_result = result;
return 0;
}

template<typename T, typename ST> int
normDiffL1_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
Expand All @@ -316,6 +372,60 @@ normDiffL1_(const T* src1, const T* src2, const uchar* mask, ST* _result, int le
*_result = result;
return 0;
}
template<> int
normDiffL1_(const uint32_t* src1, const uint32_t* src2, const uchar* mask, double* _result, int len, int cn)
{
uint64_t diff = 0;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v;
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v;
}
}
*_result = *_result + static_cast<double>(diff);
return 0;
}
template<> int
normDiffL1_(const uint64_t* src1, const uint64_t* src2, const uchar* mask, double* _result, int len, int cn)
{
double diff = 0;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += static_cast<double>(v);
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
{
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += static_cast<double>(v);
}
}
}
*_result = *_result + static_cast<double>(diff);
return 0;
}

template<typename T, typename ST> int
normDiffL2_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
Expand All @@ -332,14 +442,70 @@ normDiffL2_(const T* src1, const T* src2, const uchar* mask, ST* _result, int le
{
for( int k = 0; k < cn; k++ )
{
ST v = src1[k] - src2[k];
ST v = static_cast<ST>(src1[k] - src2[k]);
result += v*v;
}
}
}
*_result = result;
return 0;
}
template<> int
normDiffL2_(const uint32_t* src1, const uint32_t* src2, const uchar* mask, double* _result, int len, int cn)
{
uint64_t diff = 0;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v*v;
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
{
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v*v;
}
}
}
*_result = *_result + static_cast<double>(diff);
return 0;
}
template<> int
normDiffL2_(const uint64_t* src1, const uint64_t* src2, const uchar* mask, double* _result, int len, int cn)
{
uint64_t diff = 0;
if( !mask )
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v*v;
}
}
else
{
for( int i = 0; i < len; i++, src1 += cn, src2 += cn )
if( mask[i] )
{
for( int k = 0; k < cn; k++ )
{
uint64_t v = (src1[k] > src2[k])?(src1[k] - src2[k]):(src2[k] - src1[k]);
diff += v*v;
}
}
}
*_result = *_result + static_cast<double>(diff);
return 0;
}

#define CV_DEF_NORM_FUNC(L, suffix, type, ntype) \
static int norm##L##_##suffix(const type* src, const uchar* mask, ntype* r, int len, int cn) \
Expand All @@ -360,6 +526,9 @@ CV_DEF_NORM_ALL(16s, short, int, int, double)
CV_DEF_NORM_ALL(32s, int, int, double, double)
CV_DEF_NORM_ALL(32f, float, float, double, double)
CV_DEF_NORM_ALL(64f, double, double, double, double)
CV_DEF_NORM_ALL(32u, uint32_t, uint32_t, double, double)
CV_DEF_NORM_ALL(64s, int64_t, int64_t, double, double)
CV_DEF_NORM_ALL(64u, uint64_t, uint64_t, double, double)


typedef int (*NormFunc)(const uchar*, const uchar*, uchar*, int, int);
Expand All @@ -371,15 +540,24 @@ static NormFunc getNormFunc(int normType, int depth)
{
{
(NormFunc)GET_OPTIMIZED(normInf_8u), (NormFunc)GET_OPTIMIZED(normInf_8s), (NormFunc)GET_OPTIMIZED(normInf_16u), (NormFunc)GET_OPTIMIZED(normInf_16s),
(NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0
(NormFunc)GET_OPTIMIZED(normInf_32s), (NormFunc)GET_OPTIMIZED(normInf_32f), (NormFunc)normInf_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormFunc)normInf_64u, (NormFunc)normInf_64s, (NormFunc)normInf_32u
},
{
(NormFunc)GET_OPTIMIZED(normL1_8u), (NormFunc)GET_OPTIMIZED(normL1_8s), (NormFunc)GET_OPTIMIZED(normL1_16u), (NormFunc)GET_OPTIMIZED(normL1_16s),
(NormFunc)GET_OPTIMIZED(normL1_32s), (NormFunc)GET_OPTIMIZED(normL1_32f), (NormFunc)normL1_64f, 0
(NormFunc)GET_OPTIMIZED(normL1_32s), (NormFunc)GET_OPTIMIZED(normL1_32f), (NormFunc)normL1_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormFunc)normL1_64u, (NormFunc)normL1_64s, (NormFunc)normL1_32u
},
{
(NormFunc)GET_OPTIMIZED(normL2_8u), (NormFunc)GET_OPTIMIZED(normL2_8s), (NormFunc)GET_OPTIMIZED(normL2_16u), (NormFunc)GET_OPTIMIZED(normL2_16s),
(NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0
(NormFunc)GET_OPTIMIZED(normL2_32s), (NormFunc)GET_OPTIMIZED(normL2_32f), (NormFunc)normL2_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormFunc)normL2_64u, (NormFunc)normL2_64s, (NormFunc)normL2_32u
}
};

Expand All @@ -394,19 +572,28 @@ static NormDiffFunc getNormDiffFunc(int normType, int depth)
(NormDiffFunc)GET_OPTIMIZED(normDiffInf_8u), (NormDiffFunc)normDiffInf_8s,
(NormDiffFunc)normDiffInf_16u, (NormDiffFunc)normDiffInf_16s,
(NormDiffFunc)normDiffInf_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffInf_32f),
(NormDiffFunc)normDiffInf_64f, 0
(NormDiffFunc)normDiffInf_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormDiffFunc)normDiffInf_64u, (NormDiffFunc)normDiffInf_64s, (NormDiffFunc)normDiffInf_32u
},
{
(NormDiffFunc)GET_OPTIMIZED(normDiffL1_8u), (NormDiffFunc)normDiffL1_8s,
(NormDiffFunc)normDiffL1_16u, (NormDiffFunc)normDiffL1_16s,
(NormDiffFunc)normDiffL1_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL1_32f),
(NormDiffFunc)normDiffL1_64f, 0
(NormDiffFunc)normDiffL1_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormDiffFunc)normDiffL1_64u, (NormDiffFunc)normDiffL1_64s, (NormDiffFunc)normDiffL1_32u
},
{
(NormDiffFunc)GET_OPTIMIZED(normDiffL2_8u), (NormDiffFunc)normDiffL2_8s,
(NormDiffFunc)normDiffL2_16u, (NormDiffFunc)normDiffL2_16s,
(NormDiffFunc)normDiffL2_32s, (NormDiffFunc)GET_OPTIMIZED(normDiffL2_32f),
(NormDiffFunc)normDiffL2_64f, 0
(NormDiffFunc)normDiffL2_64f, 0,
0, // CV_16BF
0, // CV_Bool
(NormDiffFunc)normDiffL2_64u, (NormDiffFunc)normDiffL2_64s, (NormDiffFunc)normDiffL2_32u
}
};

Expand Down Expand Up @@ -704,6 +891,9 @@ double norm( InputArray _src, int normType, InputArray _mask )
double d;
int i;
float f;
uint64_t u64;
int64_t s64;
int32_t s32;
}
result;
result.d = 0;
Expand Down Expand Up @@ -775,6 +965,12 @@ double norm( InputArray _src, int normType, InputArray _mask )
return result.d;
else if (depth == CV_32F || depth == CV_16F)
return result.f;
else if(depth == CV_64S)
return static_cast<double>(result.s64);
else if(depth == CV_64U)
return static_cast<double>(result.u64);
else if(depth == CV_32S)
return result.s32;
else
return result.i;
}
Expand Down Expand Up @@ -1172,6 +1368,9 @@ double norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask
float f;
int i;
unsigned u;
uint64_t u64;
int64_t s64;
int32_t s32;
}
result;
result.d = 0;
Expand Down Expand Up @@ -1247,6 +1446,12 @@ double norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask
return result.d;
else if (depth == CV_32F || depth == CV_16F)
return result.f;
else if(depth == CV_64S)
return static_cast<double>(result.s64);
else if(depth == CV_64U)
return static_cast<double>(result.u64);
else if(depth == CV_32S)
return result.s32;
else
return result.u;
}
Expand Down
14 changes: 13 additions & 1 deletion modules/core/test/test_arithm.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -106,6 +106,18 @@ static const _OutputArray::DepthMask baseArithmTypeMask =
_OutputArray::DEPTH_MASK_32F |
_OutputArray::DEPTH_MASK_64F);

static const _OutputArray::DepthMask baseArithmTypeMaskV5 =
_OutputArray::DepthMask(
_OutputArray::DEPTH_MASK_8U |
_OutputArray::DEPTH_MASK_16U |
_OutputArray::DEPTH_MASK_16S |
_OutputArray::DEPTH_MASK_32S |
_OutputArray::DEPTH_MASK_32F |
_OutputArray::DEPTH_MASK_64F |
_OutputArray::DEPTH_MASK_32U |
_OutputArray::DEPTH_MASK_64U |
_OutputArray::DEPTH_MASK_64S);

struct BaseArithmOp : public BaseElemWiseOp
{
BaseArithmOp(int _ninputs, int _flags, double _alpha, double _beta, Scalar _gamma=Scalar::all(0))
Expand Down Expand Up @@ -1411,7 +1423,7 @@ struct NormOp : public BaseArithmOp
}
int getRandomType(RNG& rng)
{
int type = cvtest::randomType(rng, baseArithmTypeMask, 1, 4);
int type = cvtest::randomType(rng, baseArithmTypeMaskV5, 1, 4);
for(;;)
{
normType = rng.uniform(1, 8);
Expand Down
Loading