opencv
diff --git a/‎modules/core/CMakeLists.txt
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions b/‎modules/core/CMakeLists.txt
Copy file name to clipboard
+1Lines changed: 1 addition & 0 deletions
diff --git a/‎modules/core/src/norm.cpp renamed to ‎modules/core/src/norm.dispatch.cpp
Copy file name to clipboard
+28-122Lines changed: 28 additions & 122 deletions b/‎modules/core/src/norm.cpp renamed to ‎modules/core/src/norm.dispatch.cpp
Copy file name to clipboard
+28-122Lines changed: 28 additions & 122 deletions
@@ -12,6 +12,7 @@ ocv_add_dispatched_file(mean SSE2 AVX2 LASX)
 ocv_add_dispatched_file(merge SSE2 AVX2 LASX)
 ocv_add_dispatched_file(split SSE2 AVX2 LASX)
 ocv_add_dispatched_file(sum SSE2 AVX2 LASX)
+ocv_add_dispatched_file(norm SSE2 SSE4_1 AVX AVX2 NEON_DOTPROD LASX)
 
 # dispatching for accuracy tests
 ocv_add_dispatched_file_force_all(test_intrin128 TEST SSE2 SSE3 SSSE3 SSE4_1 SSE4_2 AVX FP16 AVX2 AVX512_SKX)
 
@@ -7,6 +7,9 @@
 #include "opencl_kernels_core.hpp"
 #include "stat.hpp"
 
+#include "norm.simd.hpp"
+#include "norm.simd_declarations.hpp"
+
 /****************************************************************************************\
 *                                         norm                                           *
 \****************************************************************************************/
@@ -215,72 +218,6 @@ int normL1_(const uchar* a, const uchar* b, int n)
 
 //==================================================================================================
 
-template<typename T, typename ST> int
-normInf_(const T* src, const uchar* mask, ST* _result, int len, int cn)
-{
-    ST result = *_result;
-    if( !mask )
-    {
-        result = std::max(result, normInf<T, ST>(src, len*cn));
-    }
-    else
-    {
-        for( int i = 0; i < len; i++, src += cn )
-            if( mask[i] )
-            {
-                for( int k = 0; k < cn; k++ )
-                    result = std::max(result, ST(cv_abs(src[k])));
-            }
-    }
-    *_result = result;
-    return 0;
-}
-
-template<typename T, typename ST> int
-normL1_(const T* src, const uchar* mask, ST* _result, int len, int cn)
-{
-    ST result = *_result;
-    if( !mask )
-    {
-        result += normL1<T, ST>(src, len*cn);
-    }
-    else
-    {
-        for( int i = 0; i < len; i++, src += cn )
-            if( mask[i] )
-            {
-                for( int k = 0; k < cn; k++ )
-                    result += cv_abs(src[k]);
-            }
-    }
-    *_result = result;
-    return 0;
-}
-
-template<typename T, typename ST> int
-normL2_(const T* src, const uchar* mask, ST* _result, int len, int cn)
-{
-    ST result = *_result;
-    if( !mask )
-    {
-        result += normL2Sqr<T, ST>(src, len*cn);
-    }
-    else
-    {
-        for( int i = 0; i < len; i++, src += cn )
-            if( mask[i] )
-            {
-                for( int k = 0; k < cn; k++ )
-                {
-                    T v = src[k];
-                    result += (ST)v*v;
-                }
-            }
-    }
-    *_result = result;
-    return 0;
-}
-
 template<typename T, typename ST> int
 normDiffInf_(const T* src1, const T* src2, const uchar* mask, ST* _result, int len, int cn)
 {
@@ -347,51 +284,27 @@ normDiffL2_(const T* src1, const T* src2, const uchar* mask, ST* _result, int le
     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) \
-{ return norm##L##_(src, mask, r, len, cn); } \
+#define CV_DEF_NORM_DIFF_FUNC(L, suffix, type, ntype) \
     static int normDiff##L##_##suffix(const type* src1, const type* src2, \
     const uchar* mask, ntype* r, int len, int cn) \
 { return normDiff##L##_(src1, src2, mask, r, (int)len, cn); }
 
-#define CV_DEF_NORM_ALL(suffix, type, inftype, l1type, l2type) \
-    CV_DEF_NORM_FUNC(Inf, suffix, type, inftype) \
-    CV_DEF_NORM_FUNC(L1, suffix, type, l1type) \
-    CV_DEF_NORM_FUNC(L2, suffix, type, l2type)
-
-CV_DEF_NORM_ALL(8u, uchar, int, int, int)
-CV_DEF_NORM_ALL(8s, schar, int, int, int)
-CV_DEF_NORM_ALL(16u, ushort, int, int, double)
-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)
+#define CV_DEF_NORM_DIFF_ALL(suffix, type, inftype, l1type, l2type) \
+    CV_DEF_NORM_DIFF_FUNC(Inf, suffix, type, inftype) \
+    CV_DEF_NORM_DIFF_FUNC(L1, suffix, type, l1type) \
+    CV_DEF_NORM_DIFF_FUNC(L2, suffix, type, l2type)
 
+CV_DEF_NORM_DIFF_ALL(8u, uchar, int, int, int)
+CV_DEF_NORM_DIFF_ALL(8s, schar, int, int, int)
+CV_DEF_NORM_DIFF_ALL(16u, ushort, int, int, double)
+CV_DEF_NORM_DIFF_ALL(16s, short, int, int, double)
+CV_DEF_NORM_DIFF_ALL(32s, int, int, double, double)
+CV_DEF_NORM_DIFF_ALL(32f, float, float, double, double)
+CV_DEF_NORM_DIFF_ALL(64f, double, double, double, double)
 
 typedef int (*NormFunc)(const uchar*, const uchar*, uchar*, int, int);
 typedef int (*NormDiffFunc)(const uchar*, const uchar*, const uchar*, uchar*, int, int);
 
-static NormFunc getNormFunc(int normType, int depth)
-{
-    static NormFunc normTab[3][8] =
-    {
-        {
-            (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(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(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
-        }
-    };
-
-    return normTab[normType][depth];
-}
-
 static NormDiffFunc getNormDiffFunc(int normType, int depth)
 {
     static NormDiffFunc normDiffTab[3][8] =
@@ -603,6 +516,11 @@ static bool ipp_norm(Mat &src, int normType, Mat &mask, double &result)
 }  // ipp_norm()
 #endif  // HAVE_IPP
 
+static NormFunc getNormFunc(int normType, int depth) {
+    CV_INSTRUMENT_REGION();
+    CV_CPU_DISPATCH(getNormFunc, (normType, depth), CV_CPU_DISPATCH_MODES_ALL);
+}
+
 double norm( InputArray _src, int normType, InputArray _mask )
 {
     CV_INSTRUMENT_REGION();
@@ -637,37 +555,28 @@ double norm( InputArray _src, int normType, InputArray _mask )
 
     CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_norm(src, normType, mask, _result), _result);
 
+    NormFunc func = getNormFunc(normType >> 1, depth == CV_16F ? CV_32F : depth);
+    CV_Assert( func != 0 );
+
     if( src.isContinuous() && mask.empty() )
     {
         size_t len = src.total()*cn;
         if( len == (size_t)(int)len )
         {
             if( depth == CV_32F )
             {
-                const float* data = src.ptr<float>();
+                const uchar* data = src.ptr<const uchar>();
 
-                if( normType == NORM_L2 )
-                {
-                    double result = 0;
-                    GET_OPTIMIZED(normL2_32f)(data, 0, &result, (int)len, 1);
-                    return std::sqrt(result);
-                }
-                if( normType == NORM_L2SQR )
+                if( normType == NORM_L2 || normType == NORM_L2SQR || normType == NORM_L1 )
                 {
                     double result = 0;
-                    GET_OPTIMIZED(normL2_32f)(data, 0, &result, (int)len, 1);
-                    return result;
-                }
-                if( normType == NORM_L1 )
-                {
-                    double result = 0;
-                    GET_OPTIMIZED(normL1_32f)(data, 0, &result, (int)len, 1);
-                    return result;
+                    func(data, 0, (uchar*)&result, (int)len, 1);
+                    return normType == NORM_L2 ? std::sqrt(result) : result;
                 }
                 if( normType == NORM_INF )
                 {
                     float result = 0;
-                    GET_OPTIMIZED(normInf_32f)(data, 0, &result, (int)len, 1);
+                    func(data, 0, (uchar*)&result, (int)len, 1);
                     return result;
                 }
             }
@@ -714,9 +623,6 @@ double norm( InputArray _src, int normType, InputArray _mask )
         return result;
     }
 
-    NormFunc func = getNormFunc(normType >> 1, depth == CV_16F ? CV_32F : depth);
-    CV_Assert( func != 0 );
-
     const Mat* arrays[] = {&src, &mask, 0};
     uchar* ptrs[2] = {};
     union