Added assertions and other check for new matrix types in cudaarithm.

asmorkalov · asmorkalov · commit c5b2a23b4e07 · 2025-09-23T22:44:51.000+03:00
diff --git a/modules/cudaarithm/src/cuda/absdiff_mat.cu b/modules/cudaarithm/src/cuda/absdiff_mat.cu
@@ -135,7 +135,7 @@ namespace
 void absDiffMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double, Stream& stream, int)
 {
     typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream);
-    static const func_t funcs[] =
+    static const func_t funcs[CV_DEPTH_MAX] =
     {
         absDiffMat_v1<uchar>,
         absDiffMat_v1<schar>,
diff --git a/modules/cudaarithm/src/cuda/absdiff_scalar.cu b/modules/cudaarithm/src/cuda/absdiff_scalar.cu
@@ -95,7 +95,7 @@ namespace
 void absDiffScalar(const GpuMat& src, cv::Scalar val, bool, GpuMat& dst, const GpuMat&, double, Stream& stream, int)
 {
     typedef void (*func_t)(const GpuMat& src, cv::Scalar val, GpuMat& dst, Stream& stream);
-    static const func_t funcs[7][4] =
+    static const func_t funcs[CV_DEPTH_MAX][4] =
     {
         {
             absDiffScalarImpl<uchar, float>, absDiffScalarImpl<uchar2, float>, absDiffScalarImpl<uchar3, float>, absDiffScalarImpl<uchar4, float>
diff --git a/modules/cudaarithm/src/cuda/cmp_scalar.cu b/modules/cudaarithm/src/cuda/cmp_scalar.cu
@@ -217,7 +217,7 @@ void cmpScalar(const GpuMat& src, cv::Scalar val, bool inv, GpuMat& dst, const G
     const int depth = src.depth();
     const int cn = src.channels();
 
-    CV_DbgAssert( depth <= CV_64F && cn <= 4 );
+    CV_Assert( depth <= CV_64F && cn <= 4 );
 
     funcs[depth][cmpop][cn - 1](src, val, dst, stream);
 }
diff --git a/modules/cudaarithm/src/cuda/div_mat.cu b/modules/cudaarithm/src/cuda/div_mat.cu
@@ -120,7 +120,7 @@ namespace
 void divMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double scale, Stream& stream, int)
 {
     typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, const GpuMat& dst, double scale, Stream& stream);
-    static const func_t funcs[7][7] =
+    static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =
     {
         {
             divMatImpl<uchar, float, uchar>,
@@ -190,8 +190,6 @@ void divMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&,
     const int sdepth = src1.depth();
     const int ddepth = dst.depth();
 
-    CV_DbgAssert( sdepth <= CV_64F && ddepth <= CV_64F );
-
     GpuMat src1_ = src1.reshape(1);
     GpuMat src2_ = src2.reshape(1);
     GpuMat dst_ = dst.reshape(1);
diff --git a/modules/cudaarithm/src/cuda/minmax.cu b/modules/cudaarithm/src/cuda/minmax.cu
@@ -87,7 +87,7 @@ namespace
 void cv::cuda::findMinMax(InputArray _src, OutputArray _dst, InputArray _mask, Stream& stream)
 {
     typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _dst, Stream& stream);
-    static const func_t funcs[] =
+    static const func_t funcs[CV_DEPTH_MAX] =
     {
         minMaxImpl<uchar, int>,
         minMaxImpl<schar, int>,
@@ -110,6 +110,8 @@ void cv::cuda::findMinMax(InputArray _src, OutputArray _dst, InputArray _mask, S
     GpuMat dst = getOutputMat(_dst, 1, 2, dst_depth, stream);
 
     const func_t func = funcs[src.depth()];
+    CV_Assert(func);
+
     func(src, mask, dst, stream);
 
     syncOutput(dst, _dst, stream);
@@ -158,7 +160,7 @@ namespace
 void cv::cuda::device::findMaxAbs(InputArray _src, OutputArray _dst, InputArray _mask, Stream& stream)
 {
     typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _dst, Stream& stream);
-    static const func_t funcs[] =
+    static const func_t funcs[CV_DEPTH_MAX] =
     {
         findMaxAbsImpl<uchar, int>,
         findMaxAbsImpl<schar, int>,
@@ -181,6 +183,8 @@ void cv::cuda::device::findMaxAbs(InputArray _src, OutputArray _dst, InputArray
     GpuMat dst = getOutputMat(_dst, 1, 1, dst_depth, stream);
 
     const func_t func = funcs[src.depth()];
+    CV_Assert(func);
+
     func(src, mask, dst, stream);
 
     syncOutput(dst, _dst, stream);
diff --git a/modules/cudaarithm/src/cuda/minmax_mat.cu b/modules/cudaarithm/src/cuda/minmax_mat.cu
@@ -127,7 +127,7 @@ namespace
 void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double, Stream& stream, int op)
 {
     typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream);
-    static const func_t funcs_v1[2][7] =
+    static const func_t funcs_v1[2][CV_DEPTH_MAX] =
     {
         {
             minMaxMat_v1<minimum, uchar>,
@@ -161,8 +161,6 @@ void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat
 
     const int depth = src1.depth();
 
-    CV_DbgAssert( depth <= CV_64F );
-
     GpuMat src1_ = src1.reshape(1);
     GpuMat src2_ = src2.reshape(1);
     GpuMat dst_ = dst.reshape(1);
@@ -191,6 +189,7 @@ void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat
     }
 
     const func_t func = funcs_v1[op][depth];
+    CV_Assert(func);
 
     func(src1_, src2_, dst_, stream);
 }
@@ -209,8 +208,10 @@ namespace
 
 void minMaxScalar(const GpuMat& src, cv::Scalar value, bool, GpuMat& dst, const GpuMat&, double, Stream& stream, int op)
 {
+    CV_DbgAssert( src.channels() == 1 );
+
     typedef void (*func_t)(const GpuMat& src, double value, GpuMat& dst, Stream& stream);
-    static const func_t funcs[2][7] =
+    static const func_t funcs[2][CV_DEPTH_MAX] =
     {
         {
             minMaxScalar<minimum, uchar>,
@@ -232,12 +233,10 @@ void minMaxScalar(const GpuMat& src, cv::Scalar value, bool, GpuMat& dst, const
         }
     };
 
-    const int depth = src.depth();
-
-    CV_DbgAssert( depth <= CV_64F );
-    CV_DbgAssert( src.channels() == 1 );
+    auto f = funcs[op][src.depth()];
+    CV_Assert(f);
 
-    funcs[op][depth](src, value[0], dst, stream);
+    f(src, value[0], dst, stream);
 }
 
 #endif
diff --git a/modules/cudaarithm/src/cuda/minmaxloc.cu b/modules/cudaarithm/src/cuda/minmaxloc.cu
@@ -75,7 +75,7 @@ namespace
 void cv::cuda::findMinMaxLoc(InputArray _src, OutputArray _minMaxVals, OutputArray _loc, InputArray _mask, Stream& stream)
 {
     typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _valBuf, GpuMat& _locBuf, Stream& stream);
-    static const func_t funcs[] =
+    static const func_t funcs[CV_DEPTH_MAX] =
     {
         minMaxLocImpl<uchar, int>,
         minMaxLocImpl<schar, int>,
@@ -99,6 +99,7 @@ void cv::cuda::findMinMaxLoc(InputArray _src, OutputArray _minMaxVals, OutputArr
     GpuMat locBuf(pool.getAllocator());
 
     const func_t func = funcs[src_depth];
+    CV_Assert(func);
     func(src, mask, valBuf, locBuf, stream);
 
     GpuMat minMaxVals = valBuf.colRange(0, 1);
diff --git a/modules/cudaarithm/src/cuda/norm.cu b/modules/cudaarithm/src/cuda/norm.cu
@@ -161,7 +161,7 @@ namespace
 void cv::cuda::device::normL2(InputArray _src, OutputArray _dst, InputArray _mask, Stream& stream)
 {
     typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _dst, Stream& stream);
-    static const func_t funcs[] =
+    static const func_t funcs[CV_DEPTH_MAX] =
     {
         normL2Impl<uchar, double>,
         normL2Impl<schar, double>,
@@ -181,6 +181,7 @@ void cv::cuda::device::normL2(InputArray _src, OutputArray _dst, InputArray _mas
     GpuMat dst = getOutputMat(_dst, 1, 1, CV_64FC1, stream);
 
     const func_t func = funcs[src.depth()];
+    CV_Assert(func);
     func(src, mask, dst, stream);
 
     syncOutput(dst, _dst, stream);
diff --git a/modules/cudaarithm/src/cuda/normalize.cu b/modules/cudaarithm/src/cuda/normalize.cu
@@ -219,7 +219,7 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,
     typedef void (*func_minmax_t)(const GpuMat& _src, GpuMat& _dst, double a, double b, const GpuMat& mask, Stream& stream);
     typedef void (*func_norm_t)(const GpuMat& _src, GpuMat& _dst, double a, int normType, const GpuMat& mask, Stream& stream);
 
-    static const func_minmax_t funcs_minmax[] =
+    static const func_minmax_t funcs_minmax[CV_DEPTH_MAX] =
     {
         normalizeMinMax<uchar, float, float>,
         normalizeMinMax<schar, float, float>,
@@ -230,7 +230,7 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,
         normalizeMinMax<double, double, double>
     };
 
-    static const func_norm_t funcs_norm[] =
+    static const func_norm_t funcs_norm[CV_DEPTH_MAX] =
     {
         normalizeNorm<uchar, float, float>,
         normalizeNorm<schar, float, float>,
@@ -273,11 +273,13 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,
     if (normType == NORM_MINMAX)
     {
         const func_minmax_t func = funcs_minmax[src_depth];
+        CV_Assert(func);
         func(src, dst, a, b, mask, stream);
     }
     else
     {
         const func_norm_t func = funcs_norm[src_depth];
+        CV_Assert(func);
         func(src, dst, a, normType, mask, stream);
     }
 
diff --git a/modules/cudaarithm/src/cuda/reduce.cu b/modules/cudaarithm/src/cuda/reduce.cu
@@ -142,7 +142,7 @@ void cv::cuda::reduce(InputArray _src, OutputArray _dst, int dim, int reduceOp,
     if (dim == 0)
     {
         typedef void (*func_t)(const GpuMat& _src, GpuMat& _dst, int reduceOp, Stream& stream);
-        static const func_t funcs[7][7] =
+        static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =
         {
             {
                 reduceToRowImpl<uchar, int, uchar>,
@@ -220,7 +220,7 @@ void cv::cuda::reduce(InputArray _src, OutputArray _dst, int dim, int reduceOp,
     else
     {
         typedef void (*func_t)(const GpuMat& _src, GpuMat& _dst, int reduceOp, Stream& stream);
-        static const func_t funcs[7][7] =
+        static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =
         {
             {
                 reduceToColumnImpl<uchar, int, uchar>,
diff --git a/modules/cudaarithm/src/cuda/sub_mat.cu b/modules/cudaarithm/src/cuda/sub_mat.cu
@@ -185,7 +185,7 @@ void subMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& m
     const int sdepth = src1.depth();
     const int ddepth = dst.depth();
 
-    CV_DbgAssert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
 
     GpuMat src1_ = src1.reshape(1);
     GpuMat src2_ = src2.reshape(1);
diff --git a/modules/cudaarithm/src/cuda/threshold.cu b/modules/cudaarithm/src/cuda/threshold.cu
@@ -374,7 +374,7 @@ double cv::cuda::threshold(InputArray _src, OutputArray _dst, double thresh, dou
     else
     {
         typedef void (*func_t)(const GpuMat& src, GpuMat& dst, double thresh, double maxVal, int type, Stream& stream);
-        static const func_t funcs[] =
+        static const func_t funcs[CV_DEPTH_MAX] =
         {
             thresholdImpl<uchar>,
             thresholdImpl<schar>,
@@ -391,7 +391,10 @@ double cv::cuda::threshold(InputArray _src, OutputArray _dst, double thresh, dou
             maxVal = cvRound(maxVal);
         }
 
-        funcs[depth](src, dst, thresh, maxVal, type, stream);
+        auto f = funcs[depth];
+        CV_Assert(f);
+
+        f(src, dst, thresh, maxVal, type, stream);
     }
 
     syncOutput(dst, _dst, stream);
diff --git a/modules/cudaarithm/test/test_element_operations.cpp b/modules/cudaarithm/test/test_element_operations.cpp
@@ -1570,13 +1570,16 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-        const func_t funcs[] =
+        const func_t funcs[CV_DEPTH_MAX] =
         {
             sqrtImpl<uchar>, sqrtImpl<schar>, sqrtImpl<ushort>, sqrtImpl<short>,
             sqrtImpl<int>, sqrtImpl<float>
         };
 
-        funcs[src.depth()](src, dst);
+        auto f = funcs[src.depth()];
+        CV_Assert(f);
+
+        f(src, dst);
     }
 }
 
@@ -1640,13 +1643,16 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-        const func_t funcs[] =
+        const func_t funcs[CV_DEPTH_MAX] =
         {
             logImpl<uchar>, logImpl<schar>, logImpl<ushort>, logImpl<short>,
             logImpl<int>, logImpl<float>
         };
 
-        funcs[src.depth()](src, dst);
+        auto f = funcs[src.depth()];
+        CV_Assert(f);
+
+        f(src, dst);
     }
 }
 
@@ -1720,13 +1726,16 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-        const func_t funcs[] =
+        const func_t funcs[CV_DEPTH_MAX] =
         {
             expImpl<uchar>, expImpl<schar>, expImpl<ushort>, expImpl<short>,
             expImpl<int>, expImpl_float
         };
 
-        funcs[src.depth()](src, dst);
+        auto f = funcs[src.depth()];
+        CV_Assert(f);
+
+        f(src, dst);
     }
 }
 
@@ -1921,8 +1930,10 @@ namespace
 
     void compareScalarGold(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst, int cmpop)
     {
+        CV_Assert(cmpop < 6);
+
         typedef void (*func_t)(const cv::Mat& src, cv::Scalar sc, cv::Mat& dst);
-        static const func_t funcs[7][6] =
+        static const func_t funcs[CV_DEPTH_MAX][6] =
         {
             {compareScalarImpl<std::equal_to, unsigned char> , compareScalarImpl<std::greater, unsigned char> , compareScalarImpl<std::greater_equal, unsigned char> , compareScalarImpl<std::less, unsigned char> , compareScalarImpl<std::less_equal, unsigned char> , compareScalarImpl<std::not_equal_to, unsigned char> },
             {compareScalarImpl<std::equal_to, signed char>   , compareScalarImpl<std::greater, signed char>   , compareScalarImpl<std::greater_equal, signed char>   , compareScalarImpl<std::less, signed char>   , compareScalarImpl<std::less_equal, signed char>   , compareScalarImpl<std::not_equal_to, signed char>   },
@@ -1933,7 +1944,10 @@ namespace
             {compareScalarImpl<std::equal_to, double>        , compareScalarImpl<std::greater, double>        , compareScalarImpl<std::greater_equal, double>        , compareScalarImpl<std::less, double>        , compareScalarImpl<std::less_equal, double>        , compareScalarImpl<std::not_equal_to, double>        }
         };
 
-        funcs[src.depth()][cmpop](src, sc, dst);
+        auto f = funcs[src.depth()][cmpop];
+        CV_Assert(f);
+
+        f(src, sc, dst);
     }
 }
 
@@ -2164,12 +2178,14 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
 
-        const func_t funcs[] =
+        const func_t funcs[CV_DEPTH_MAX] =
         {
             rhiftImpl<uchar>, rhiftImpl<schar>, rhiftImpl<ushort>, rhiftImpl<short>, rhiftImpl<int>
         };
 
-        funcs[src.depth()](src, val, dst);
+        auto f = funcs[src.depth()];
+        CV_Assert(f);
+        f(src, val, dst);
     }
 }
 
@@ -2244,12 +2260,15 @@ namespace
     {
         typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
 
-        const func_t funcs[] =
+        const func_t funcs[CV_DEPTH_MAX] =
         {
             lhiftImpl<uchar>, lhiftImpl<schar>, lhiftImpl<ushort>, lhiftImpl<short>, lhiftImpl<int>
         };
 
-        funcs[src.depth()](src, val, dst);
+        auto f = funcs[src.depth()];
+        CV_Assert(f);
+
+        f(src, val, dst);
     }
 }
 
diff --git a/modules/cudaarithm/test/test_reductions.cpp b/modules/cudaarithm/test/test_reductions.cpp

Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ namespace`
`135`	`135`	`void absDiffMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double, Stream& stream, int)`
`136`	`136`	`{`
`137`	`137`	`typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream);`
`138`		`- static const func_t funcs[] =`
	`138`	`+ static const func_t funcs[CV_DEPTH_MAX] =`
`139`	`139`	`{`
`140`	`140`	`absDiffMat_v1<uchar>,`
`141`	`141`	`absDiffMat_v1<schar>,`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ namespace`
`95`	`95`	`void absDiffScalar(const GpuMat& src, cv::Scalar val, bool, GpuMat& dst, const GpuMat&, double, Stream& stream, int)`
`96`	`96`	`{`
`97`	`97`	`typedef void (*func_t)(const GpuMat& src, cv::Scalar val, GpuMat& dst, Stream& stream);`
`98`		`- static const func_t funcs[7][4] =`
	`98`	`+ static const func_t funcs[CV_DEPTH_MAX][4] =`
`99`	`99`	`{`
`100`	`100`	`{`
`101`	`101`	`absDiffScalarImpl<uchar, float>, absDiffScalarImpl<uchar2, float>, absDiffScalarImpl<uchar3, float>, absDiffScalarImpl<uchar4, float>`
Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ void cmpScalar(const GpuMat& src, cv::Scalar val, bool inv, GpuMat& dst, const G`
`217`	`217`	`const int depth = src.depth();`
`218`	`218`	`const int cn = src.channels();`
`219`	`219`
`220`		`- CV_DbgAssert( depth <= CV_64F && cn <= 4 );`
	`220`	`+ CV_Assert( depth <= CV_64F && cn <= 4 );`
`221`	`221`
`222`	`222`	`funcs[depth][cmpop][cn - 1](src, val, dst, stream);`
`223`	`223`	`}`
Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ namespace`
`120`	`120`	`void divMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double scale, Stream& stream, int)`
`121`	`121`	`{`
`122`	`122`	`typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, const GpuMat& dst, double scale, Stream& stream);`
`123`		`- static const func_t funcs[7][7] =`
	`123`	`+ static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =`
`124`	`124`	`{`
`125`	`125`	`{`
`126`	`126`	`divMatImpl<uchar, float, uchar>,`
`@@ -190,8 +190,6 @@ void divMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&,`
`190`	`190`	`const int sdepth = src1.depth();`
`191`	`191`	`const int ddepth = dst.depth();`
`192`	`192`
`193`		`- CV_DbgAssert( sdepth <= CV_64F && ddepth <= CV_64F );`
`194`		`-`
`195`	`193`	`GpuMat src1_ = src1.reshape(1);`
`196`	`194`	`GpuMat src2_ = src2.reshape(1);`
`197`	`195`	`GpuMat dst_ = dst.reshape(1);`
Original file line number	Diff line number	Diff line change
`@@ -127,7 +127,7 @@ namespace`
`127`	`127`	`void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat&, double, Stream& stream, int op)`
`128`	`128`	`{`
`129`	`129`	`typedef void (*func_t)(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream);`
`130`		`- static const func_t funcs_v1[2][7] =`
	`130`	`+ static const func_t funcs_v1[2][CV_DEPTH_MAX] =`
`131`	`131`	`{`
`132`	`132`	`{`
`133`	`133`	`minMaxMat_v1<minimum, uchar>,`
`@@ -161,8 +161,6 @@ void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat`
`161`	`161`
`162`	`162`	`const int depth = src1.depth();`
`163`	`163`
`164`		`- CV_DbgAssert( depth <= CV_64F );`
`165`		`-`
`166`	`164`	`GpuMat src1_ = src1.reshape(1);`
`167`	`165`	`GpuMat src2_ = src2.reshape(1);`
`168`	`166`	`GpuMat dst_ = dst.reshape(1);`
`@@ -191,6 +189,7 @@ void minMaxMat(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat`
`191`	`189`	`}`
`192`	`190`
`193`	`191`	`const func_t func = funcs_v1[op][depth];`
	`192`	`+ CV_Assert(func);`
`194`	`193`
`195`	`194`	`func(src1_, src2_, dst_, stream);`
`196`	`195`	`}`
`@@ -209,8 +208,10 @@ namespace`
`209`	`208`
`210`	`209`	`void minMaxScalar(const GpuMat& src, cv::Scalar value, bool, GpuMat& dst, const GpuMat&, double, Stream& stream, int op)`
`211`	`210`	`{`
	`211`	`+ CV_DbgAssert( src.channels() == 1 );`
	`212`	`+`
`212`	`213`	`typedef void (*func_t)(const GpuMat& src, double value, GpuMat& dst, Stream& stream);`
`213`		`- static const func_t funcs[2][7] =`
	`214`	`+ static const func_t funcs[2][CV_DEPTH_MAX] =`
`214`	`215`	`{`
`215`	`216`	`{`
`216`	`217`	`minMaxScalar<minimum, uchar>,`
`@@ -232,12 +233,10 @@ void minMaxScalar(const GpuMat& src, cv::Scalar value, bool, GpuMat& dst, const`
`232`	`233`	`}`
`233`	`234`	`};`
`234`	`235`
`235`		`- const int depth = src.depth();`
`236`		`-`
`237`		`- CV_DbgAssert( depth <= CV_64F );`
`238`		`- CV_DbgAssert( src.channels() == 1 );`
	`236`	`+ auto f = funcs[op][src.depth()];`
	`237`	`+ CV_Assert(f);`
`239`	`238`
`240`		`- funcs[op][depth](src, value[0], dst, stream);`
	`239`	`+ f(src, value[0], dst, stream);`
`241`	`240`	`}`
`242`	`241`
`243`	`242`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ namespace`
`75`	`75`	`void cv::cuda::findMinMaxLoc(InputArray _src, OutputArray _minMaxVals, OutputArray _loc, InputArray _mask, Stream& stream)`
`76`	`76`	`{`
`77`	`77`	`typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _valBuf, GpuMat& _locBuf, Stream& stream);`
`78`		`- static const func_t funcs[] =`
	`78`	`+ static const func_t funcs[CV_DEPTH_MAX] =`
`79`	`79`	`{`
`80`	`80`	`minMaxLocImpl<uchar, int>,`
`81`	`81`	`minMaxLocImpl<schar, int>,`
`@@ -99,6 +99,7 @@ void cv::cuda::findMinMaxLoc(InputArray _src, OutputArray _minMaxVals, OutputArr`
`99`	`99`	`GpuMat locBuf(pool.getAllocator());`
`100`	`100`
`101`	`101`	`const func_t func = funcs[src_depth];`
	`102`	`+ CV_Assert(func);`
`102`	`103`	`func(src, mask, valBuf, locBuf, stream);`
`103`	`104`
`104`	`105`	`GpuMat minMaxVals = valBuf.colRange(0, 1);`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ namespace`
`161`	`161`	`void cv::cuda::device::normL2(InputArray _src, OutputArray _dst, InputArray _mask, Stream& stream)`
`162`	`162`	`{`
`163`	`163`	`typedef void (*func_t)(const GpuMat& _src, const GpuMat& mask, GpuMat& _dst, Stream& stream);`
`164`		`- static const func_t funcs[] =`
	`164`	`+ static const func_t funcs[CV_DEPTH_MAX] =`
`165`	`165`	`{`
`166`	`166`	`normL2Impl<uchar, double>,`
`167`	`167`	`normL2Impl<schar, double>,`
`@@ -181,6 +181,7 @@ void cv::cuda::device::normL2(InputArray _src, OutputArray _dst, InputArray _mas`
`181`	`181`	`GpuMat dst = getOutputMat(_dst, 1, 1, CV_64FC1, stream);`
`182`	`182`
`183`	`183`	`const func_t func = funcs[src.depth()];`
	`184`	`+ CV_Assert(func);`
`184`	`185`	`func(src, mask, dst, stream);`
`185`	`186`
`186`	`187`	`syncOutput(dst, _dst, stream);`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,`
`219`	`219`	`typedef void (*func_minmax_t)(const GpuMat& _src, GpuMat& _dst, double a, double b, const GpuMat& mask, Stream& stream);`
`220`	`220`	`typedef void (*func_norm_t)(const GpuMat& _src, GpuMat& _dst, double a, int normType, const GpuMat& mask, Stream& stream);`
`221`	`221`
`222`		`- static const func_minmax_t funcs_minmax[] =`
	`222`	`+ static const func_minmax_t funcs_minmax[CV_DEPTH_MAX] =`
`223`	`223`	`{`
`224`	`224`	`normalizeMinMax<uchar, float, float>,`
`225`	`225`	`normalizeMinMax<schar, float, float>,`
`@@ -230,7 +230,7 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,`
`230`	`230`	`normalizeMinMax<double, double, double>`
`231`	`231`	`};`
`232`	`232`
`233`		`- static const func_norm_t funcs_norm[] =`
	`233`	`+ static const func_norm_t funcs_norm[CV_DEPTH_MAX] =`
`234`	`234`	`{`
`235`	`235`	`normalizeNorm<uchar, float, float>,`
`236`	`236`	`normalizeNorm<schar, float, float>,`
`@@ -273,11 +273,13 @@ void cv::cuda::normalize(InputArray _src, OutputArray _dst, double a, double b,`
`273`	`273`	`if (normType == NORM_MINMAX)`
`274`	`274`	`{`
`275`	`275`	`const func_minmax_t func = funcs_minmax[src_depth];`
	`276`	`+ CV_Assert(func);`
`276`	`277`	`func(src, dst, a, b, mask, stream);`
`277`	`278`	`}`
`278`	`279`	`else`
`279`	`280`	`{`
`280`	`281`	`const func_norm_t func = funcs_norm[src_depth];`
	`282`	`+ CV_Assert(func);`
`281`	`283`	`func(src, dst, a, normType, mask, stream);`
`282`	`284`	`}`
`283`	`285`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ void cv::cuda::reduce(InputArray _src, OutputArray _dst, int dim, int reduceOp,`
`142`	`142`	`if (dim == 0)`
`143`	`143`	`{`
`144`	`144`	`typedef void (*func_t)(const GpuMat& _src, GpuMat& _dst, int reduceOp, Stream& stream);`
`145`		`- static const func_t funcs[7][7] =`
	`145`	`+ static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =`
`146`	`146`	`{`
`147`	`147`	`{`
`148`	`148`	`reduceToRowImpl<uchar, int, uchar>,`
`@@ -220,7 +220,7 @@ void cv::cuda::reduce(InputArray _src, OutputArray _dst, int dim, int reduceOp,`
`220`	`220`	`else`
`221`	`221`	`{`
`222`	`222`	`typedef void (*func_t)(const GpuMat& _src, GpuMat& _dst, int reduceOp, Stream& stream);`
`223`		`- static const func_t funcs[7][7] =`
	`223`	`+ static const func_t funcs[CV_DEPTH_MAX][CV_DEPTH_MAX] =`
`224`	`224`	`{`
`225`	`225`	`{`
`226`	`226`	`reduceToColumnImpl<uchar, int, uchar>,`