added vecmath to gpu module.

modules/gpu/src/cuda/saturate_cast.hpp

@@ -163,92 +163,6 @@ namespace cv
             return saturate_cast<uint>((float)v);
         #endif
         }
-
-        template<typename _Tp> static __device__ _Tp saturate_cast(uchar4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(char4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(ushort4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(short4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(uint4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(int4 v) { return _Tp(v); }
-        template<typename _Tp> static __device__ _Tp saturate_cast(float4 v) { return _Tp(v); }
-
-        template<> static __device__ uchar4 saturate_cast<uchar4>(char4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-        template<> static __device__ uchar4 saturate_cast<uchar4>(ushort4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-        template<> static __device__ uchar4 saturate_cast<uchar4>(short4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-        template<> static __device__ uchar4 saturate_cast<uchar4>(uint4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-        template<> static __device__ uchar4 saturate_cast<uchar4>(int4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-        template<> static __device__ uchar4 saturate_cast<uchar4>(float4 v)
-        { return make_uchar4(saturate_cast<uchar>(v.x), saturate_cast<uchar>(v.y), saturate_cast<uchar>(v.z), saturate_cast<uchar>(v.w)); }
-
-        template<> static __device__ char4 saturate_cast<char4>(uchar4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-        template<> static __device__ char4 saturate_cast<char4>(ushort4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-        template<> static __device__ char4 saturate_cast<char4>(short4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-        template<> static __device__ char4 saturate_cast<char4>(uint4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-        template<> static __device__ char4 saturate_cast<char4>(int4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-        template<> static __device__ char4 saturate_cast<char4>(float4 v)
-        { return make_char4(saturate_cast<char>(v.x), saturate_cast<char>(v.y), saturate_cast<char>(v.z), saturate_cast<char>(v.w)); }
-
-        template<> static __device__ ushort4 saturate_cast<ushort4>(uchar4 v)
-        { return make_ushort4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ ushort4 saturate_cast<ushort4>(char4 v)
-        { return make_ushort4(saturate_cast<ushort>(v.x), saturate_cast<ushort>(v.y), saturate_cast<ushort>(v.z), saturate_cast<ushort>(v.w)); }
-        template<> static __device__ ushort4 saturate_cast<ushort4>(short4 v)
-        { return make_ushort4(saturate_cast<ushort>(v.x), saturate_cast<ushort>(v.y), saturate_cast<ushort>(v.z), saturate_cast<ushort>(v.w)); }
-        template<> static __device__ ushort4 saturate_cast<ushort4>(uint4 v)
-        { return make_ushort4(saturate_cast<ushort>(v.x), saturate_cast<ushort>(v.y), saturate_cast<ushort>(v.z), saturate_cast<ushort>(v.w)); }
-        template<> static __device__ ushort4 saturate_cast<ushort4>(int4 v)
-        { return make_ushort4(saturate_cast<ushort>(v.x), saturate_cast<ushort>(v.y), saturate_cast<ushort>(v.z), saturate_cast<ushort>(v.w)); }
-        template<> static __device__ ushort4 saturate_cast<ushort4>(float4 v)
-        { return make_ushort4(saturate_cast<ushort>(v.x), saturate_cast<ushort>(v.y), saturate_cast<ushort>(v.z), saturate_cast<ushort>(v.w)); }
-
-        template<> static __device__ short4 saturate_cast<short4>(uchar4 v)
-        { return make_short4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ short4 saturate_cast<short4>(char4 v)
-        { return make_short4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ short4 saturate_cast<short4>(ushort4 v)
-        { return make_short4(saturate_cast<short>(v.x), saturate_cast<short>(v.y), saturate_cast<short>(v.z), saturate_cast<short>(v.w)); }
-        template<> static __device__ short4 saturate_cast<short4>(uint4 v)
-        { return make_short4(saturate_cast<short>(v.x), saturate_cast<short>(v.y), saturate_cast<short>(v.z), saturate_cast<short>(v.w)); }
-        template<> static __device__ short4 saturate_cast<short4>(int4 v)
-        { return make_short4(saturate_cast<short>(v.x), saturate_cast<short>(v.y), saturate_cast<short>(v.z), saturate_cast<short>(v.w)); }
-        template<> static __device__ short4 saturate_cast<short4>(float4 v)
-        { return make_short4(saturate_cast<short>(v.x), saturate_cast<short>(v.y), saturate_cast<short>(v.z), saturate_cast<short>(v.w)); }
-        
-        template<> static __device__ uint4 saturate_cast<uint4>(uchar4 v)
-        { return make_uint4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ uint4 saturate_cast<uint4>(char4 v)
-        { return make_uint4(saturate_cast<uint>(v.x), saturate_cast<uint>(v.y), saturate_cast<uint>(v.z), saturate_cast<uint>(v.w)); }
-        template<> static __device__ uint4 saturate_cast<uint4>(ushort4 v)
-        { return make_uint4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ uint4 saturate_cast<uint4>(short4 v)
-        { return make_uint4(saturate_cast<uint>(v.x), saturate_cast<uint>(v.y), saturate_cast<uint>(v.z), saturate_cast<uint>(v.w)); }
-        template<> static __device__ uint4 saturate_cast<uint4>(int4 v)
-        { return make_uint4(saturate_cast<uint>(v.x), saturate_cast<uint>(v.y), saturate_cast<uint>(v.z), saturate_cast<uint>(v.w)); }
-        template<> static __device__ uint4 saturate_cast<uint4>(float4 v)
-        { return make_uint4(saturate_cast<uint>(v.x), saturate_cast<uint>(v.y), saturate_cast<uint>(v.z), saturate_cast<uint>(v.w)); }
-        
-        template<> static __device__ int4 saturate_cast<int4>(uchar4 v)
-        { return make_int4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ int4 saturate_cast<int4>(char4 v)
-        { return make_int4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ int4 saturate_cast<int4>(ushort4 v)
-        { return make_int4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ int4 saturate_cast<int4>(short4 v)
-        { return make_int4(v.x, v.y, v.z, v.w); }
-        template<> static __device__ int4 saturate_cast<int4>(uint4 v)
-        { return make_int4(saturate_cast<int>(v.x), saturate_cast<int>(v.y), saturate_cast<int>(v.z), saturate_cast<int>(v.w)); }
-        template<> static __device__ int4 saturate_cast<int4>(float4 v)
-        { return make_int4(saturate_cast<int>(v.x), saturate_cast<int>(v.y), saturate_cast<int>(v.z), saturate_cast<int>(v.w)); }
     }
 }
 

modules/gpu/src/cudastream.cpp

@@ -163,7 +163,7 @@ void cv::gpu::Stream::waitForCompletion() { cudaSafeCall( cudaStreamSynchronize(
 void cv::gpu::Stream::enqueueDownload(const GpuMat& src, Mat& dst)
 {
     // if not -> allocation will be done, but after that dst will not point to page locked memory
-    CV_Assert(src.cols == dst.cols && src.rows == dst.rows && src.type() == dst.type() )
+    CV_Assert(src.cols == dst.cols && src.rows == dst.rows && src.type() == dst.type() );
     devcopy(src, dst, impl->stream, cudaMemcpyDeviceToHost);
 }
 void cv::gpu::Stream::enqueueDownload(const GpuMat& src, CudaMem& dst) { devcopy(src, dst, impl->stream, cudaMemcpyDeviceToHost); }

modules/gpu/src/filtering.cpp

@@ -577,15 +577,31 @@ void cv::gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& ke
 
 namespace cv { namespace gpu { namespace filters
 {
-    void linearRowFilter_gpu_32s32s(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearRowFilter_gpu_32s32f(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearRowFilter_gpu_32f32s(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearRowFilter_gpu_32f32f(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-
-    void linearColumnFilter_gpu_32s32s(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearColumnFilter_gpu_32s32f(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearColumnFilter_gpu_32f32s(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
-    void linearColumnFilter_gpu_32f32f(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_8u_8u_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_8u_8s_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_8s_8u_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_8s_8s_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_16u_16u_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_16u_16s_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_16s_16u_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_16s_16s_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_32s_32s_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_32s_32f_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_32f_32s_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearRowFilter_gpu_32f_32f_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+
+    void linearColumnFilter_gpu_8u_8u_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_8u_8s_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_8s_8u_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_8s_8s_c4(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_16u_16u_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_16u_16s_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_16s_16u_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_16s_16s_c2(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_32s_32s_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_32s_32f_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_32f_32s_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
+    void linearColumnFilter_gpu_32f_32f_c1(const DevMem2D& src, const DevMem2D& dst, const float kernel[], int ksize, int anchor);
 }}}
 
 namespace
@@ -637,15 +653,15 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
     static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterRow_8u_C1R, 0, 0, nppiFilterRow_8u_C4R};
     static const gpuFilter1D_t gpuFilter1D_callers[6][6] =
     {
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,linearRowFilter_gpu_32s32s, linearRowFilter_gpu_32s32f},
-        {0,0,0,0,linearRowFilter_gpu_32f32s, linearRowFilter_gpu_32f32f}
+        {linearRowFilter_gpu_8u_8u_c4,linearRowFilter_gpu_8u_8s_c4,0,0,0,0},
+        {linearRowFilter_gpu_8s_8u_c4,linearRowFilter_gpu_8s_8s_c4,0,0,0,0},
+        {0,0,linearRowFilter_gpu_16u_16u_c2,linearRowFilter_gpu_16u_16s_c2,0,0},
+        {0,0,linearRowFilter_gpu_16s_16u_c2,linearRowFilter_gpu_16s_16s_c2,0,0},
+        {0,0,0,0,linearRowFilter_gpu_32s_32s_c1, linearRowFilter_gpu_32s_32f_c1},
+        {0,0,0,0,linearRowFilter_gpu_32f_32s_c1, linearRowFilter_gpu_32f_32f_c1}
     };
     
-    if ((srcType == CV_8UC1 || srcType == CV_8UC4) && bufType == srcType)
+    if ((bufType == srcType) && (srcType == CV_8UC1 || srcType == CV_8UC4))
     {
         GpuMat gpu_row_krnl;
         int nDivisor;
@@ -657,8 +673,10 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
         return Ptr<BaseRowFilter_GPU>(new NppLinearRowFilter(ksize, anchor, gpu_row_krnl, nDivisor,
             nppFilter1D_callers[CV_MAT_CN(srcType)]));
     }
-    else if ((srcType == CV_32SC1 || srcType == CV_32FC1) && (bufType == CV_32SC1 || bufType == CV_32FC1))
-    {
+
+    CV_Assert(srcType == CV_8UC4 || srcType == CV_8SC4 || srcType == CV_16UC2 || srcType == CV_16SC2 || srcType == CV_32SC1 || srcType == CV_32FC1);
+    CV_Assert(bufType == CV_8UC4 || bufType == CV_8SC4 || bufType == CV_16UC2 || bufType == CV_16SC2 || bufType == CV_32SC1 || bufType == CV_32FC1);
+
     Mat temp(rowKernel.size(), CV_32FC1);
     rowKernel.convertTo(temp, CV_32FC1);
     Mat cont_krnl = temp.reshape(1, 1);
@@ -668,10 +686,6 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
 
     return Ptr<BaseRowFilter_GPU>(new GpuLinearRowFilter(ksize, anchor, cont_krnl, 
         gpuFilter1D_callers[CV_MAT_DEPTH(srcType)][CV_MAT_DEPTH(bufType)]));
-    }
-
-    CV_Assert(!"Unsupported types");  
-    return Ptr<BaseRowFilter_GPU>(0);
 }
 
 namespace
@@ -718,15 +732,18 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
     static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterColumn_8u_C1R, 0, 0, nppiFilterColumn_8u_C4R};
     static const gpuFilter1D_t gpuFilter1D_callers[6][6] =
     {
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,0,0},
-        {0,0,0,0,linearColumnFilter_gpu_32s32s, linearColumnFilter_gpu_32s32f},
-        {0,0,0,0,linearColumnFilter_gpu_32f32s, linearColumnFilter_gpu_32f32f}
+        {linearColumnFilter_gpu_8u_8u_c4,linearColumnFilter_gpu_8u_8s_c4,0,0,0,0},
+        {linearColumnFilter_gpu_8s_8u_c4,linearColumnFilter_gpu_8s_8s_c4,0,0,0,0},
+        {0,0,linearColumnFilter_gpu_16u_16u_c2,linearColumnFilter_gpu_16u_16s_c2,0,0},
+        {0,0,linearColumnFilter_gpu_16s_16u_c2,linearColumnFilter_gpu_16s_16s_c2,0,0},
+        {0,0,0,0,linearColumnFilter_gpu_32s_32s_c1, linearColumnFilter_gpu_32s_32f_c1},
+        {0,0,0,0,linearColumnFilter_gpu_32f_32s_c1, linearColumnFilter_gpu_32f_32f_c1}
     };
     
-    if ((bufType == CV_8UC1 || bufType == CV_8UC4) && dstType == bufType)
+    double kernelMin;
+    minMaxLoc(columnKernel, &kernelMin);
+    
+    if ((bufType == dstType) && (bufType == CV_8UC1 || bufType == CV_8UC4))
     {
         GpuMat gpu_col_krnl;
         int nDivisor;
@@ -738,8 +755,10 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
         return Ptr<BaseColumnFilter_GPU>(new NppLinearColumnFilter(ksize, anchor, gpu_col_krnl, nDivisor, 
             nppFilter1D_callers[CV_MAT_CN(bufType)]));
     }
-    else if ((bufType == CV_32SC1 || bufType == CV_32FC1) && (dstType == CV_32SC1 || dstType == CV_32FC1))
-    {
+
+    CV_Assert(dstType == CV_8UC4 || dstType == CV_8SC4 || dstType == CV_16UC2 || dstType == CV_16SC2 || dstType == CV_32SC1 || dstType == CV_32FC1);
+    CV_Assert(bufType == CV_8UC4 || bufType == CV_8SC4 || bufType == CV_16UC2 || bufType == CV_16SC2 || bufType == CV_32SC1 || bufType == CV_32FC1);
+
     Mat temp(columnKernel.size(), CV_32FC1);
     columnKernel.convertTo(temp, CV_32FC1);
     Mat cont_krnl = temp.reshape(1, 1);
@@ -749,10 +768,6 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
 
     return Ptr<BaseColumnFilter_GPU>(new GpuLinearColumnFilter(ksize, anchor, cont_krnl, 
         gpuFilter1D_callers[CV_MAT_DEPTH(bufType)][CV_MAT_DEPTH(dstType)]));
-    }
-
-    CV_Assert(!"Unsupported types");  
-    return Ptr<BaseColumnFilter_GPU>(0);
 }
 
 Ptr<FilterEngine_GPU> cv::gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, 

modules/gpu/src/imgproc_gpu.cpp

@@ -652,7 +652,7 @@ void cv::gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const
 
 double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh) 
 { 
-    CV_Assert(src.type() == CV_32FC1)
+    CV_Assert(src.type() == CV_32FC1);
 
     dst.create( src.size(), src.type() );
 

tests/gpu/src/filters.cpp

@@ -166,6 +166,8 @@ struct CV_GpuNppImageSobelTest : public CV_GpuNppFilterTest
 
     int test(const Mat& img)
     {
+        if (img.type() != CV_8UC1)
+            return CvTS::OK;
         int ksizes[] = {3, 5, 7};
         int ksizes_num = sizeof(ksizes) / sizeof(int);
 
@@ -181,8 +183,10 @@ struct CV_GpuNppImageSobelTest : public CV_GpuNppFilterTest
             cv::Sobel(img, cpudst, -1, dx, dy, ksizes[i]);
 
             GpuMat gpu1(img);
+            gpu1.convertTo(gpu1, CV_32S);
             GpuMat gpudst;
             cv::gpu::Sobel(gpu1, gpudst, -1, dx, dy, ksizes[i]);
+            gpudst.convertTo(gpudst, CV_8U);
 
             if (CheckNorm(cpudst, gpudst, Size(ksizes[i], ksizes[i])) != CvTS::OK)
                 test_res = CvTS::FAIL_GENERIC;
@@ -200,14 +204,19 @@ struct CV_GpuNppImageScharrTest : public CV_GpuNppFilterTest
 
     int test(const Mat& img)
     {
+        if (img.type() != CV_8UC1)
+            return CvTS::OK;
+
         int dx = 1, dy = 0;
 
         Mat cpudst;
         cv::Scharr(img, cpudst, -1, dx, dy);
 
         GpuMat gpu1(img);
+        gpu1.convertTo(gpu1, CV_32S);
         GpuMat gpudst;
         cv::gpu::Scharr(gpu1, gpudst, -1, dx, dy);
+        gpudst.convertTo(gpudst, CV_8U);
         
         return CheckNorm(cpudst, gpudst, Size(3, 3));
     }