moved GpuMat and DevMem2D to core module, some code refactoring

modules/gpu/src/cuda/bf_radius_match.cu

@@ -45,421 +45,423 @@
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace bf_radius_match
+namespace bf_radius_match {
+
+///////////////////////////////////////////////////////////////////////////////
+// Match Unrolled
+
+template <int BLOCK_SIZE, int MAX_DESC_LEN, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
+__global__ void matchUnrolled(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
+    PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
 {
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match Unrolled
+    #if __CUDA_ARCH__ >= 110
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
-    __global__ void matchUnrolled(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
-        PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
+    extern __shared__ int smem[];
+
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+
+    Dist dist;
+
+    #pragma unroll
+    for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
     {
-        #if __CUDA_ARCH__ >= 110
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-        extern __shared__ int smem[];
+        s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+        s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+        if (loadX < query.cols)
+        {
+            T val;
 
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+            ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-        Dist dist;
+            ForceGlob<T>::Load(train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
+        }
+
+        __syncthreads();
 
         #pragma unroll
-        for (int i = 0; i < MAX_DESC_LEN / BLOCK_SIZE; ++i)
-        {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
-
-            if (loadX < query.cols)
-            {
-                T val;
-
-                ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
-
-                ForceGlob<T>::Load(train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-            }
-
-            __syncthreads();
-
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
-
-            __syncthreads();
-        }
-
-        float distVal = (typename Dist::result_type)dist;
-
-        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
-        {
-            unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
-            if (ind < maxCount)
-            {
-                bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
-                if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
-                bestDistance.ptr(queryIdx)[ind] = distVal;
-            }
-        }
-
-        #endif
+        __syncthreads();
     }
 
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, cudaStream_t stream)
+    float distVal = (typename Dist::result_type)dist;
+
+    if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+        unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
+        if (ind < maxCount)
+        {
+            bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
+            if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
+            bestDistance.ptr(queryIdx)[ind] = distVal;
+        }
+    }
+
+    #endif
+}
+
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
+
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+
+    matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
+        trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}   
+
+template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T> 
+void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+
+    for (int i = 0; i < n; ++i)
+    {
+        const DevMem2D_<T> train = trains[i];
+
         const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
-
-        matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
-            trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+        if (masks != 0 && masks[i].data)
+        {
+            matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
+        }
+        else
+        {
+            matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
+        }
         cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }   
-
-    template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T> 
-    void matchUnrolled(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
-    {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
-
-        for (int i = 0; i < n; ++i)
-        {
-            const DevMem2D_<T> train = trains[i];
-
-            const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
-
-            if (masks != 0 && masks[i].data)
-            {
-                matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            else
-            {
-                matchUnrolled<BLOCK_SIZE, MAX_DESC_LEN, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            cudaSafeCall( cudaGetLastError() );
-        }
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
     }
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <int BLOCK_SIZE, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
-    __global__ void match(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
-        PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
+///////////////////////////////////////////////////////////////////////////////
+// Match
+
+template <int BLOCK_SIZE, bool SAVE_IMG_IDX, typename Dist, typename T, typename Mask>
+__global__ void match(const DevMem2D_<T> query, int imgIdx, const DevMem2D_<T> train, float maxDistance, const Mask mask,
+    PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
+{
+    #if __CUDA_ARCH__ >= 110
+
+    extern __shared__ int smem[];
+
+    const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
+    const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
+
+    typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
+    typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
+
+    Dist dist;
+
+    for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
     {
-        #if __CUDA_ARCH__ >= 110
+        const int loadX = threadIdx.x + i * BLOCK_SIZE;
 
-        extern __shared__ int smem[];
+        s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
+        s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
 
-        const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
-        const int trainIdx = blockIdx.x * BLOCK_SIZE + threadIdx.x;
-
-        typename Dist::value_type* s_query = (typename Dist::value_type*)(smem);
-        typename Dist::value_type* s_train = (typename Dist::value_type*)(smem + BLOCK_SIZE * BLOCK_SIZE);
-
-        Dist dist;
-
-        for (int i = 0, endi = (query.cols + BLOCK_SIZE - 1) / BLOCK_SIZE; i < endi; ++i)
+        if (loadX < query.cols)
         {
-            const int loadX = threadIdx.x + i * BLOCK_SIZE;
+            T val;
 
-            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = 0;
-            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = 0;
+            ForceGlob<T>::Load(query.ptr(::min(queryIdx, query.rows - 1)), loadX, val);
+            s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
 
-            if (loadX < query.cols)
-            {
-                T val;
-
-                ForceGlob<T>::Load(query.ptr(min(queryIdx, query.rows - 1)), loadX, val);
-                s_query[threadIdx.y * BLOCK_SIZE + threadIdx.x] = val;
-
-                ForceGlob<T>::Load(train.ptr(min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
-                s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
-            }
-
-            __syncthreads();
-
-            #pragma unroll
-            for (int j = 0; j < BLOCK_SIZE; ++j)
-                dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
-
-            __syncthreads();
+            ForceGlob<T>::Load(train.ptr(::min(blockIdx.x * BLOCK_SIZE + threadIdx.y, train.rows - 1)), loadX, val);
+            s_train[threadIdx.x * BLOCK_SIZE + threadIdx.y] = val;
         }
 
-        float distVal = (typename Dist::result_type)dist;
+        __syncthreads();
 
-        if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
-        {
-            unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
-            if (ind < maxCount)
-            {
-                bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
-                if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
-                bestDistance.ptr(queryIdx)[ind] = distVal;
-            }
-        }
+        #pragma unroll
+        for (int j = 0; j < BLOCK_SIZE; ++j)
+            dist.reduceIter(s_query[threadIdx.y * BLOCK_SIZE + j], s_train[j * BLOCK_SIZE + threadIdx.x]);
 
-        #endif
+        __syncthreads();
     }
 
-    template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
+    float distVal = (typename Dist::result_type)dist;
+
+    if (queryIdx < query.rows && trainIdx < train.rows && mask(queryIdx, trainIdx) && distVal < maxDistance)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+        unsigned int ind = atomicInc(nMatches + queryIdx, (unsigned int) -1);
+        if (ind < maxCount)
+        {
+            bestTrainIdx.ptr(queryIdx)[ind] = trainIdx;
+            if (SAVE_IMG_IDX) bestImgIdx.ptr(queryIdx)[ind] = imgIdx;
+            bestDistance.ptr(queryIdx)[ind] = distVal;
+        }
+    }
+
+    #endif
+}
+
+template <int BLOCK_SIZE, typename Dist, typename T, typename Mask> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+    const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
+
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+
+    match<BLOCK_SIZE, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
+        trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <int BLOCK_SIZE, typename Dist, typename T> 
+void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    cudaStream_t stream)
+{
+    const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
+
+    const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
+
+    for (int i = 0; i < n; ++i)
+    {
+        const DevMem2D_<T> train = trains[i];
+
         const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
 
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
-
-        match<BLOCK_SIZE, false, Dist><<<grid, block, smemSize, stream>>>(query, 0, train, maxDistance, mask, 
-            trainIdx, PtrStepi(), distance, nMatches.data, trainIdx.cols);
+        if (masks != 0 && masks[i].data)
+        {
+            match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
+        }
+        else
+        {
+            match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
+                trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
+        }
         cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
     }
 
-    template <int BLOCK_SIZE, typename Dist, typename T> 
-    void match(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        cudaStream_t stream)
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Match dispatcher
+
+template <typename Dist, typename T, typename Mask> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
+                     const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        const dim3 block(BLOCK_SIZE, BLOCK_SIZE);
-
-        const size_t smemSize = (2 * BLOCK_SIZE * BLOCK_SIZE) * sizeof(int);
-
-        for (int i = 0; i < n; ++i)
-        {
-            const DevMem2D_<T> train = trains[i];
-
-            const dim3 grid(divUp(train.rows, BLOCK_SIZE), divUp(query.rows, BLOCK_SIZE));
-
-            if (masks != 0 && masks[i].data)
-            {
-                match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, SingleMask(masks[i]), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            else
-            {
-                match<BLOCK_SIZE, true, Dist><<<grid, block, smemSize, stream>>>(query, i, train, maxDistance, WithOutMask(), 
-                    trainIdx, imgIdx, distance, nMatches.data, trainIdx.cols);
-            }
-            cudaSafeCall( cudaGetLastError() );
-        }
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        matchUnrolled<16, 64, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
-
-    ///////////////////////////////////////////////////////////////////////////////
-    // Match dispatcher
-
-    template <typename Dist, typename T, typename Mask> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>& train, float maxDistance, const Mask& mask, 
-                         const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-                         int cc, cudaStream_t stream)
+    else if (query.cols <= 128)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolled<16, 64, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolled<16, 128, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
-        }
+        matchUnrolled<16, 128, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
-
-    template <typename Dist, typename T> 
-    void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
-                         const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-                         int cc, cudaStream_t stream)
+    /*else if (query.cols <= 256)
     {
-        if (query.cols <= 64)
-        {
-            matchUnrolled<16, 64, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 128)
-        {
-            matchUnrolled<16, 128, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        /*else if (query.cols <= 256)
-        {
-            matchUnrolled<16, 256, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 512)
-        {            
-            matchUnrolled<16, 512, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-        else if (query.cols <= 1024)
-        {            
-            matchUnrolled<16, 1024, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }*/
-        else
-        {
-            match<16, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
-        }
-    } 
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    // Radius Match caller
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
-    {
-        if (mask.data)
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+        matchUnrolled<16, 256, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
-
-    template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
-    {
-        if (mask.data)
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
-
-    //template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
-        const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
+    }*/
+    else
     {
-        if (mask.data)
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
-        else
-        {
-            matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
-                trainIdx, distance, nMatches, 
-                cc, stream);
-        }
+        match<16, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
     }
+}
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+template <typename Dist, typename T> 
+void matchDispatcher(const DevMem2D_<T>& query, const DevMem2D_<T>* trains, int n, float maxDistance, const DevMem2Db* masks, 
+                     const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+                     int cc, cudaStream_t stream)
+{
+    if (query.cols <= 64)
     {
-        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchUnrolled<16, 64, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 128)
+    {
+        matchUnrolled<16, 128, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    /*else if (query.cols <= 256)
+    {
+        matchUnrolled<16, 256, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 512)
+    {            
+        matchUnrolled<16, 512, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+    else if (query.cols <= 1024)
+    {            
+        matchUnrolled<16, 1024, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }*/
+    else
+    {
+        match<16, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
+    }
+} 
+
+///////////////////////////////////////////////////////////////////////////////
+// Radius Match caller
+
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
-
-    template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-
-    template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+    else
     {
-        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
+}
 
-    //template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
 
-    template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
-        const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
-        int cc, cudaStream_t stream)
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
     {
-        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
-            trainIdx, imgIdx, distance, nMatches, 
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
             cc, stream);
     }
+    else
+    {
+        matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+}
 
-    template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    //template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-    template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
-}}}
+//template void matchL2_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db& train, float maxDistance, const DevMem2Db& mask, 
+    const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    if (mask.data)
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, SingleMask(mask), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+    else
+    {
+        matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), static_cast< DevMem2D_<T> >(train), maxDistance, WithOutMask(), 
+            trainIdx, distance, nMatches, 
+            cc, stream);
+    }
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& queryDescs, const DevMem2Db& trainDescs, float maxDistance, const DevMem2Db& mask, const DevMem2Di& trainIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchL1_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher< L1Dist<T> >(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+template void matchL1_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL1_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL1_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchL2_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher<L2Dist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+//template void matchL2_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchL2_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchL2_gpu<float >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+template <typename T> void matchHamming_gpu(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, 
+    const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, 
+    int cc, cudaStream_t stream)
+{
+    matchDispatcher<HammingDist>(static_cast< DevMem2D_<T> >(query), (const DevMem2D_<T>*)trains, n, maxDistance, masks, 
+        trainIdx, imgIdx, distance, nMatches, 
+        cc, stream);
+}
+
+template void matchHamming_gpu<uchar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<schar >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<ushort>(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+//template void matchHamming_gpu<short >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+template void matchHamming_gpu<int   >(const DevMem2Db& query, const DevMem2Db* trains, int n, float maxDistance, const DevMem2Db* masks, const DevMem2Di& trainIdx, const DevMem2Di& imgIdx, const DevMem2Df& distance, const DevMem2D_<unsigned int>& nMatches, int cc, cudaStream_t stream);
+
+} // namespace bf_radius_match
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/bilateral_filter.cu

@@ -43,191 +43,186 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace bf_krnls
+namespace bilateral_filter {
+
+__constant__ float* ctable_color;
+__constant__ float* ctable_space;
+__constant__ size_t ctable_space_step;
+
+__constant__ int cndisp;
+__constant__ int cradius;
+
+__constant__ short cedge_disc;
+__constant__ short cmax_disc;
+
+void load_constants(float* table_color, DevMem2Df table_space, int ndisp, int radius, short edge_disc, short max_disc)
 {
-    __constant__ float* ctable_color;
-    __constant__ float* ctable_space;
-    __constant__ size_t ctable_space_step;
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_color, &table_color, sizeof(table_color)) );
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_space, &table_space.data, sizeof(table_space.data)) );
+    size_t table_space_step = table_space.step / sizeof(float);
+    cudaSafeCall( cudaMemcpyToSymbol(ctable_space_step, &table_space_step, sizeof(size_t)) );
 
-    __constant__ int cndisp;
-    __constant__ int cradius;
+    cudaSafeCall( cudaMemcpyToSymbol(cndisp, &ndisp, sizeof(int)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cradius, &radius, sizeof(int)) );
 
-    __constant__ short cedge_disc;
-    __constant__ short cmax_disc;
+    cudaSafeCall( cudaMemcpyToSymbol(cedge_disc, &edge_disc, sizeof(short)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_disc, &max_disc, sizeof(short)) );
 }
 
-namespace cv { namespace gpu { namespace bf 
+template <int channels>
+struct DistRgbMax
 {
-    void load_constants(float* table_color, const DevMem2Df& table_space, int ndisp, int radius, short edge_disc, short max_disc)
+    static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
     {
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_color, &table_color, sizeof(table_color)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_space, &table_space.data, sizeof(table_space.data)) );
-        size_t table_space_step = table_space.step / sizeof(float);
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::ctable_space_step, &table_space_step, sizeof(size_t)) );
-
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cndisp, &ndisp, sizeof(int)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cradius, &radius, sizeof(int)) );
-
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cedge_disc, &edge_disc, sizeof(short)) );
-        cudaSafeCall( cudaMemcpyToSymbol(bf_krnls::cmax_disc, &max_disc, sizeof(short)) );
+        uchar x = ::abs(a[0] - b[0]);
+        uchar y = ::abs(a[1] - b[1]);
+        uchar z = ::abs(a[2] - b[2]);
+        return (::max(::max(x, y), z));
     }
-}}}
+};
 
-namespace bf_krnls
+template <>
+struct DistRgbMax<1>
 {
-    template <int channels>
-    struct DistRgbMax
+    static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
     {
-        static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
-        {
-            uchar x = abs(a[0] - b[0]);
-            uchar y = abs(a[1] - b[1]);
-            uchar z = abs(a[2] - b[2]);
-            return (max(max(x, y), z));
-        }
-    };
+        return ::abs(a[0] - b[0]);
+    }
+};
 
-    template <>
-    struct DistRgbMax<1>
+template <int channels, typename T>
+__global__ void bilateral_filter(int t, T* disp, size_t disp_step, const uchar* img, size_t img_step, int h, int w)
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+
+    T dp[5];
+
+    if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
     {
-        static __device__ __forceinline__ uchar calc(const uchar* a, const uchar* b)
+        dp[0] = *(disp + (y  ) * disp_step + x + 0);
+        dp[1] = *(disp + (y-1) * disp_step + x + 0);
+        dp[2] = *(disp + (y  ) * disp_step + x - 1);
+        dp[3] = *(disp + (y+1) * disp_step + x + 0);
+        dp[4] = *(disp + (y  ) * disp_step + x + 1);
+
+        if(::abs(dp[1] - dp[0]) >= cedge_disc || ::abs(dp[2] - dp[0]) >= cedge_disc || ::abs(dp[3] - dp[0]) >= cedge_disc || ::abs(dp[4] - dp[0]) >= cedge_disc)            
         {
-            return abs(a[0] - b[0]);
-        }
-    };
+            const int ymin = ::max(0, y - cradius);
+            const int xmin = ::max(0, x - cradius);
+            const int ymax = ::min(h - 1, y + cradius);
+            const int xmax = ::min(w - 1, x + cradius);
 
-    template <int channels, typename T>
-    __global__ void bilateral_filter(int t, T* disp, size_t disp_step, const uchar* img, size_t img_step, int h, int w)
-    {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+            float cost[] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
 
-        T dp[5];
+            const uchar* ic = img + y * img_step + channels * x;
 
-        if (y > 0 && y < h - 1 && x > 0 && x < w - 1)
-        {
-            dp[0] = *(disp + (y  ) * disp_step + x + 0);
-            dp[1] = *(disp + (y-1) * disp_step + x + 0);
-            dp[2] = *(disp + (y  ) * disp_step + x - 1);
-            dp[3] = *(disp + (y+1) * disp_step + x + 0);
-            dp[4] = *(disp + (y  ) * disp_step + x + 1);
-
-            if(abs(dp[1] - dp[0]) >= cedge_disc || abs(dp[2] - dp[0]) >= cedge_disc || abs(dp[3] - dp[0]) >= cedge_disc || abs(dp[4] - dp[0]) >= cedge_disc)            
+            for(int yi = ymin; yi <= ymax; yi++)
             {
-                const int ymin = max(0, y - cradius);
-                const int xmin = max(0, x - cradius);
-                const int ymax = min(h - 1, y + cradius);
-                const int xmax = min(w - 1, x + cradius);
+                const T* disp_y = disp + yi * disp_step;
 
-                float cost[] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
-
-                const uchar* ic = img + y * img_step + channels * x;
-
-                for(int yi = ymin; yi <= ymax; yi++)
+                for(int xi = xmin; xi <= xmax; xi++)
                 {
-                    const T* disp_y = disp + yi * disp_step;
+                    const uchar* in = img + yi * img_step + channels * xi;
 
-                    for(int xi = xmin; xi <= xmax; xi++)
-                    {
-                        const uchar* in = img + yi * img_step + channels * xi;
+                    uchar dist_rgb = DistRgbMax<channels>::calc(in, ic);
 
-                        uchar dist_rgb = DistRgbMax<channels>::calc(in, ic);
+                    const float weight = ctable_color[dist_rgb] * (ctable_space + ::abs(y-yi)* ctable_space_step)[::abs(x-xi)];
 
-                        const float weight = ctable_color[dist_rgb] * (ctable_space + abs(y-yi)* ctable_space_step)[abs(x-xi)];
+                    const T disp_reg = disp_y[xi];
 
-                        const T disp_reg = disp_y[xi];
-
-                        cost[0] += min(cmax_disc, abs(disp_reg - dp[0])) * weight;
-                        cost[1] += min(cmax_disc, abs(disp_reg - dp[1])) * weight;
-                        cost[2] += min(cmax_disc, abs(disp_reg - dp[2])) * weight;
-                        cost[3] += min(cmax_disc, abs(disp_reg - dp[3])) * weight;
-                        cost[4] += min(cmax_disc, abs(disp_reg - dp[4])) * weight;
-                    }
+                    cost[0] += ::min(cmax_disc, ::abs(disp_reg - dp[0])) * weight;
+                    cost[1] += ::min(cmax_disc, ::abs(disp_reg - dp[1])) * weight;
+                    cost[2] += ::min(cmax_disc, ::abs(disp_reg - dp[2])) * weight;
+                    cost[3] += ::min(cmax_disc, ::abs(disp_reg - dp[3])) * weight;
+                    cost[4] += ::min(cmax_disc, ::abs(disp_reg - dp[4])) * weight;
                 }
-
-                float minimum = numeric_limits<float>::max();
-                int id = 0;
-
-                if (cost[0] < minimum)
-                {
-                    minimum = cost[0];
-                    id = 0;
-                }
-                if (cost[1] < minimum)
-                {
-                    minimum = cost[1];
-                    id = 1;
-                }
-                if (cost[2] < minimum)
-                {
-                    minimum = cost[2];
-                    id = 2;
-                }
-                if (cost[3] < minimum)
-                {
-                    minimum = cost[3];
-                    id = 3;
-                }
-                if (cost[4] < minimum)
-                {
-                    minimum = cost[4];
-                    id = 4;
-                }
-
-                *(disp + y * disp_step + x) = dp[id];
             }
+
+            float minimum = numeric_limits<float>::max();
+            int id = 0;
+
+            if (cost[0] < minimum)
+            {
+                minimum = cost[0];
+                id = 0;
+            }
+            if (cost[1] < minimum)
+            {
+                minimum = cost[1];
+                id = 1;
+            }
+            if (cost[2] < minimum)
+            {
+                minimum = cost[2];
+                id = 2;
+            }
+            if (cost[3] < minimum)
+            {
+                minimum = cost[3];
+                id = 3;
+            }
+            if (cost[4] < minimum)
+            {
+                minimum = cost[4];
+                id = 4;
+            }
+
+            *(disp + y * disp_step + x) = dp[id];
         }
     }
 }
 
-namespace cv { namespace gpu { namespace bf 
+template <typename T>     
+void bilateral_filter_caller(DevMem2D_<T> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
 {
-    template <typename T>     
-    void bilateral_filter_caller(const DevMem2D_<T>& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-        grid.x = divUp(disp.cols, threads.x << 1);
-        grid.y = divUp(disp.rows, threads.y);
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+    grid.x = divUp(disp.cols, threads.x << 1);
+    grid.y = divUp(disp.rows, threads.y);
 
-        switch (channels)
+    switch (channels)
+    {
+    case 1:
+        for (int i = 0; i < iters; ++i)
         {
-        case 1:
-            for (int i = 0; i < iters; ++i)
-            {
-                bf_krnls::bilateral_filter<1><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-                bf_krnls::bilateral_filter<1><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-            }
-            break;
-        case 3:
-            for (int i = 0; i < iters; ++i)
-            {
-                bf_krnls::bilateral_filter<3><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-                bf_krnls::bilateral_filter<3><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
-                cudaSafeCall( cudaGetLastError() );
-            }
-            break;
-        default:
-            cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
+            bilateral_filter<1><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
+
+            bilateral_filter<1><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
         }
+        break;
+    case 3:
+        for (int i = 0; i < iters; ++i)
+        {
+            bilateral_filter<3><<<grid, threads, 0, stream>>>(0, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
 
-        if (stream != 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+            bilateral_filter<3><<<grid, threads, 0, stream>>>(1, disp.data, disp.step/sizeof(T), img.data, img.step, disp.rows, disp.cols);
+            cudaSafeCall( cudaGetLastError() );
+        }
+        break;
+    default:
+        cv::gpu::error("Unsupported channels count", __FILE__, __LINE__);
     }
 
-    void bilateral_filter_gpu(const DevMem2Db& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        bilateral_filter_caller(disp, img, channels, iters, stream);
-    }
+    if (stream != 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    void bilateral_filter_gpu(const DevMem2D_<short>& disp, const DevMem2Db& img, int channels, int iters, cudaStream_t stream)
-    {
-        bilateral_filter_caller(disp, img, channels, iters, stream);
-    }
-}}}
+void bilateral_filter_gpu(DevMem2Db disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
+{
+    bilateral_filter_caller(disp, img, channels, iters, stream);
+}
+
+void bilateral_filter_gpu(DevMem2D_<short> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream)
+{
+    bilateral_filter_caller(disp, img, channels, iters, stream);
+}
+
+} // namespace bilateral_filter
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/blend.cu

@@ -42,81 +42,77 @@
 
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu 
+namespace blend {
+
+template <typename T>
+__global__ void blendLinearKernel(int rows, int cols, int cn, const PtrStep<T> img1, const PtrStep<T> img2,
+                                  const PtrStepf weights1, const PtrStepf weights2, PtrStep<T> result)
 {
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-    template <typename T>
-    __global__ void blendLinearKernel(int rows, int cols, int cn, const PtrStep<T> img1, const PtrStep<T> img2,
-                                      const PtrStepf weights1, const PtrStepf weights2, PtrStep<T> result)
+    if (y < rows && x < cols)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (y < rows && x < cols)
-        {
-            int x_ = x / cn;
-            float w1 = weights1.ptr(y)[x_];
-            float w2 = weights2.ptr(y)[x_];
-            T p1 = img1.ptr(y)[x];
-            T p2 = img2.ptr(y)[x];
-            result.ptr(y)[x] = (p1 * w1 + p2 * w2) / (w1 + w2 + 1e-5f);
-        }
-    }	
-
-    template <typename T>
-    void blendLinearCaller(int rows, int cols, int cn, const PtrStep<T>& img1, const PtrStep<T>& img2, 
-                           const PtrStepf& weights1, const PtrStepf& weights2, PtrStep<T> result, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols * cn, threads.x), divUp(rows, threads.y));
-        
-        blendLinearKernel<<<grid, threads, 0, stream>>>(rows, cols * cn, cn, img1, img2, weights1, weights2, result);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
+        int x_ = x / cn;
+        float w1 = weights1.ptr(y)[x_];
+        float w2 = weights2.ptr(y)[x_];
+        T p1 = img1.ptr(y)[x];
+        T p2 = img2.ptr(y)[x];
+        result.ptr(y)[x] = (p1 * w1 + p2 * w2) / (w1 + w2 + 1e-5f);
     }
+}	
 
-    template void blendLinearCaller<uchar>(int, int, int, const PtrStep<uchar>&, const PtrStep<uchar>&, 
-                                           const PtrStepf&, const PtrStepf&, PtrStep<uchar>, cudaStream_t stream);
-    template void blendLinearCaller<float>(int, int, int, const PtrStep<float>&, const PtrStep<float>&, 
-                                           const PtrStepf&, const PtrStepf&, PtrStep<float>, cudaStream_t stream);
+template <typename T>
+void blendLinearCaller(int rows, int cols, int cn, PtrStep<T> img1, PtrStep<T> img2, PtrStepf weights1, PtrStepf weights2, PtrStep<T> result, cudaStream_t stream)
+{
+    dim3 threads(16, 16);
+    dim3 grid(divUp(cols * cn, threads.x), divUp(rows, threads.y));
+    
+    blendLinearKernel<<<grid, threads, 0, stream>>>(rows, cols * cn, cn, img1, img2, weights1, weights2, result);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+template void blendLinearCaller<uchar>(int, int, int, PtrStep<uchar>, PtrStep<uchar>, PtrStepf, PtrStepf, PtrStep<uchar>, cudaStream_t stream);
+template void blendLinearCaller<float>(int, int, int, PtrStep<float>, PtrStep<float>, PtrStepf, PtrStepf, PtrStep<float>, cudaStream_t stream);
 
 
-    __global__ void blendLinearKernel8UC4(int rows, int cols, const PtrStepb img1, const PtrStepb img2,
-                                          const PtrStepf weights1, const PtrStepf weights2, PtrStepb result)
+__global__ void blendLinearKernel8UC4(int rows, int cols, const PtrStepb img1, const PtrStepb img2,
+                                      const PtrStepf weights1, const PtrStepf weights2, PtrStepb result)
+{
+    int x = blockIdx.x * blockDim.x + threadIdx.x;
+    int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y < rows && x < cols)
     {
-        int x = blockIdx.x * blockDim.x + threadIdx.x;
-        int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (y < rows && x < cols)
-        {
-            float w1 = weights1.ptr(y)[x];
-            float w2 = weights2.ptr(y)[x];
-            float sum_inv = 1.f / (w1 + w2 + 1e-5f);
-            w1 *= sum_inv;
-            w2 *= sum_inv;
-            uchar4 p1 = ((const uchar4*)img1.ptr(y))[x];
-            uchar4 p2 = ((const uchar4*)img2.ptr(y))[x];
-            ((uchar4*)result.ptr(y))[x] = make_uchar4(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2,
-                                                      p1.z * w1 + p2.z * w2, p1.w * w1 + p2.w * w2);
-        }
+        float w1 = weights1.ptr(y)[x];
+        float w2 = weights2.ptr(y)[x];
+        float sum_inv = 1.f / (w1 + w2 + 1e-5f);
+        w1 *= sum_inv;
+        w2 *= sum_inv;
+        uchar4 p1 = ((const uchar4*)img1.ptr(y))[x];
+        uchar4 p2 = ((const uchar4*)img2.ptr(y))[x];
+        ((uchar4*)result.ptr(y))[x] = make_uchar4(p1.x * w1 + p2.x * w2, p1.y * w1 + p2.y * w2,
+                                                  p1.z * w1 + p2.z * w2, p1.w * w1 + p2.w * w2);
     }
+}
 
+void blendLinearCaller8UC4(int rows, int cols, PtrStepb img1, PtrStepb img2, PtrStepf weights1, PtrStepf weights2, PtrStepb result, cudaStream_t stream)
+{
+    dim3 threads(16, 16);
+    dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
+    
+    blendLinearKernel8UC4<<<grid, threads, 0, stream>>>(rows, cols, img1, img2, weights1, weights2, result);
+    cudaSafeCall( cudaGetLastError() );
 
-    void blendLinearCaller8UC4(int rows, int cols, const PtrStepb& img1, const PtrStepb& img2, 
-                               const PtrStepf& weights1, const PtrStepf& weights2, PtrStepb result, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
-        
-        blendLinearKernel8UC4<<<grid, threads, 0, stream>>>(rows, cols, img1, img2, weights1, weights2, result);
-        cudaSafeCall( cudaGetLastError() );
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
 
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
+} // namespace blend 
 
-}}
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/calib3d.cu

@@ -44,153 +44,149 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 #define SOLVE_PNP_RANSAC_MAX_NUM_ITERS 200
 
-using namespace cv::gpu::device;
-
-namespace cv { namespace gpu
+namespace transform_points
 {
-    namespace transform_points
+    __constant__ float3 crot0;
+    __constant__ float3 crot1;
+    __constant__ float3 crot2;
+    __constant__ float3 ctransl;
+
+    struct TransformOp : unary_function<float3, float3>
     {
-        __constant__ float3 crot0;
-        __constant__ float3 crot1;
-        __constant__ float3 crot2;
-        __constant__ float3 ctransl;
-
-        struct TransformOp : unary_function<float3, float3>
+        __device__ __forceinline__ float3 operator()(const float3& p) const
         {
-            __device__ __forceinline__ float3 operator()(const float3& p) const
-            {
-                return make_float3(
-                        crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
-                        crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
-                        crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
-            }
-        };
-
-        void call(const DevMem2D_<float3> src, const float* rot,
-                  const float* transl, DevMem2D_<float3> dst,
-                  cudaStream_t stream)
-        {
-            cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
-            transform(src, dst, TransformOp(), stream);
+            return make_float3(
+                    crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
+                    crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
+                    crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
         }
-    } // namespace transform_points
+    };
 
-
-    namespace project_points
+    void call(const DevMem2D_<float3> src, const float* rot,
+              const float* transl, DevMem2D_<float3> dst,
+              cudaStream_t stream)
     {
-        __constant__ float3 crot0;
-        __constant__ float3 crot1;
-        __constant__ float3 crot2;
-        __constant__ float3 ctransl;
-        __constant__ float3 cproj0;
-        __constant__ float3 cproj1;
+        cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
+        OPENCV_DEVICE_NAMESPACE_ transform(src, dst, TransformOp(), stream);
+    }
+} // namespace transform_points
 
-        struct ProjectOp : unary_function<float3, float3>
-        {
-            __device__ __forceinline__ float2 operator()(const float3& p) const
-            {
-                // Rotate and translate in 3D
-                float3 t = make_float3(
-                        crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
-                        crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
-                        crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
-                // Project on 2D plane
-                return make_float2(
-                        (cproj0.x * t.x + cproj0.y * t.y) / t.z + cproj0.z,
-                        (cproj1.x * t.x + cproj1.y * t.y) / t.z + cproj1.z);
-            }
-        };
+namespace project_points
+{
+    __constant__ float3 crot0;
+    __constant__ float3 crot1;
+    __constant__ float3 crot2;
+    __constant__ float3 ctransl;
+    __constant__ float3 cproj0;
+    __constant__ float3 cproj1;
 
-        void call(const DevMem2D_<float3> src, const float* rot,
-                  const float* transl, const float* proj, DevMem2D_<float2> dst,
-                  cudaStream_t stream)
-        {
-            cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
-            cudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
-            transform(src, dst, ProjectOp(), stream);
-        }
-    } // namespace project_points
-
-
-    namespace solve_pnp_ransac
+    struct ProjectOp : unary_function<float3, float3>
     {
-        __constant__ float3 crot_matrices[SOLVE_PNP_RANSAC_MAX_NUM_ITERS * 3];
-        __constant__ float3 ctransl_vectors[SOLVE_PNP_RANSAC_MAX_NUM_ITERS];
-
-        int maxNumIters()
+        __device__ __forceinline__ float2 operator()(const float3& p) const
         {
-            return SOLVE_PNP_RANSAC_MAX_NUM_ITERS;
+            // Rotate and translate in 3D
+            float3 t = make_float3(
+                    crot0.x * p.x + crot0.y * p.y + crot0.z * p.z + ctransl.x,
+                    crot1.x * p.x + crot1.y * p.y + crot1.z * p.z + ctransl.y,
+                    crot2.x * p.x + crot2.y * p.y + crot2.z * p.z + ctransl.z);
+            // Project on 2D plane
+            return make_float2(
+                    (cproj0.x * t.x + cproj0.y * t.y) / t.z + cproj0.z,
+                    (cproj1.x * t.x + cproj1.y * t.y) / t.z + cproj1.z);
+        }
+    };
+
+    void call(const DevMem2D_<float3> src, const float* rot,
+              const float* transl, const float* proj, DevMem2D_<float2> dst,
+              cudaStream_t stream)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(crot0, rot, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot1, rot + 3, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(crot2, rot + 6, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl, transl, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(cproj0, proj, sizeof(float) * 3));
+        cudaSafeCall(cudaMemcpyToSymbol(cproj1, proj + 3, sizeof(float) * 3));
+        OPENCV_DEVICE_NAMESPACE_ transform(src, dst, ProjectOp(), stream);
+    }
+} // namespace project_points
+
+namespace solve_pnp_ransac
+{
+    __constant__ float3 crot_matrices[SOLVE_PNP_RANSAC_MAX_NUM_ITERS * 3];
+    __constant__ float3 ctransl_vectors[SOLVE_PNP_RANSAC_MAX_NUM_ITERS];
+
+    int maxNumIters()
+    {
+        return SOLVE_PNP_RANSAC_MAX_NUM_ITERS;
+    }
+
+    __device__ __forceinline__ float sqr(float x)
+    {
+        return x * x;
+    }
+
+    __global__ void computeHypothesisScoresKernel(
+            const int num_points, const float3* object, const float2* image,
+            const float dist_threshold, int* g_num_inliers)
+    {
+        const float3* const &rot_mat = crot_matrices + blockIdx.x * 3;
+        const float3 &transl_vec = ctransl_vectors[blockIdx.x];
+        int num_inliers = 0;
+
+        for (int i = threadIdx.x; i < num_points; i += blockDim.x)
+        {
+            float3 p = object[i];
+            p = make_float3(
+                    rot_mat[0].x * p.x + rot_mat[0].y * p.y + rot_mat[0].z * p.z + transl_vec.x,
+                    rot_mat[1].x * p.x + rot_mat[1].y * p.y + rot_mat[1].z * p.z + transl_vec.y,
+                    rot_mat[2].x * p.x + rot_mat[2].y * p.y + rot_mat[2].z * p.z + transl_vec.z);
+            p.x /= p.z;
+            p.y /= p.z;
+            float2 image_p = image[i];
+            if (sqr(p.x - image_p.x) + sqr(p.y - image_p.y) < dist_threshold)
+                ++num_inliers;
         }
 
-        __device__ __forceinline__ float sqr(float x)
+        extern __shared__ float s_num_inliers[];
+        s_num_inliers[threadIdx.x] = num_inliers;
+        __syncthreads();
+
+        for (int step = blockDim.x / 2; step > 0; step >>= 1)
         {
-            return x * x;
-        }
-
-        __global__ void computeHypothesisScoresKernel(
-                const int num_points, const float3* object, const float2* image,
-                const float dist_threshold, int* g_num_inliers)
-        {
-            const float3* const &rot_mat = crot_matrices + blockIdx.x * 3;
-            const float3 &transl_vec = ctransl_vectors[blockIdx.x];
-            int num_inliers = 0;
-
-            for (int i = threadIdx.x; i < num_points; i += blockDim.x)
-            {
-                float3 p = object[i];
-                p = make_float3(
-                        rot_mat[0].x * p.x + rot_mat[0].y * p.y + rot_mat[0].z * p.z + transl_vec.x,
-                        rot_mat[1].x * p.x + rot_mat[1].y * p.y + rot_mat[1].z * p.z + transl_vec.y,
-                        rot_mat[2].x * p.x + rot_mat[2].y * p.y + rot_mat[2].z * p.z + transl_vec.z);
-                p.x /= p.z;
-                p.y /= p.z;
-                float2 image_p = image[i];
-                if (sqr(p.x - image_p.x) + sqr(p.y - image_p.y) < dist_threshold)
-                    ++num_inliers;
-            }
-
-            extern __shared__ float s_num_inliers[];
-            s_num_inliers[threadIdx.x] = num_inliers;
+            if (threadIdx.x < step)
+                s_num_inliers[threadIdx.x] += s_num_inliers[threadIdx.x + step];
             __syncthreads();
-
-            for (int step = blockDim.x / 2; step > 0; step >>= 1)
-            {
-                if (threadIdx.x < step)
-                    s_num_inliers[threadIdx.x] += s_num_inliers[threadIdx.x + step];
-                __syncthreads();
-            }
-
-            if (threadIdx.x == 0)
-                g_num_inliers[blockIdx.x] = s_num_inliers[0];
         }
 
-        void computeHypothesisScores(
-                const int num_hypotheses, const int num_points, const float* rot_matrices,
-                const float3* transl_vectors, const float3* object, const float2* image,
-                const float dist_threshold, int* hypothesis_scores)
-        {
-            cudaSafeCall(cudaMemcpyToSymbol(crot_matrices, rot_matrices, num_hypotheses * 3 * sizeof(float3)));
-            cudaSafeCall(cudaMemcpyToSymbol(ctransl_vectors, transl_vectors, num_hypotheses * sizeof(float3)));
+        if (threadIdx.x == 0)
+            g_num_inliers[blockIdx.x] = s_num_inliers[0];
+    }
 
-            dim3 threads(256);
-            dim3 grid(num_hypotheses);
-            int smem_size = threads.x * sizeof(float);
+    void computeHypothesisScores(
+            const int num_hypotheses, const int num_points, const float* rot_matrices,
+            const float3* transl_vectors, const float3* object, const float2* image,
+            const float dist_threshold, int* hypothesis_scores)
+    {
+        cudaSafeCall(cudaMemcpyToSymbol(crot_matrices, rot_matrices, num_hypotheses * 3 * sizeof(float3)));
+        cudaSafeCall(cudaMemcpyToSymbol(ctransl_vectors, transl_vectors, num_hypotheses * sizeof(float3)));
 
-            computeHypothesisScoresKernel<<<grid, threads, smem_size>>>(
-                    num_points, object, image, dist_threshold, hypothesis_scores);
-            cudaSafeCall( cudaGetLastError() );
+        dim3 threads(256);
+        dim3 grid(num_hypotheses);
+        int smem_size = threads.x * sizeof(float);
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    } // namespace solvepnp_ransac
+        computeHypothesisScoresKernel<<<grid, threads, smem_size>>>(
+                num_points, object, image, dist_threshold, hypothesis_scores);
+        cudaSafeCall( cudaGetLastError() );
 
-}} // namespace cv { namespace gpu
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+} // namespace solvepnp_ransac
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/canny.cu

@@ -44,339 +44,370 @@
 #include <algorithm>
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace canny
+namespace canny {
+
+__global__ void calcSobelRowPass(const PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
 {
-    __global__ void calcSobelRowPass(const PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+    __shared__ int smem[16][18];
+
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (i < rows)
     {
-        __shared__ int smem[16][18];
-
-        const int j = blockIdx.x * blockDim.x + threadIdx.x;
-        const int i = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (i < rows)
+        smem[threadIdx.y][threadIdx.x + 1] = src.ptr(i)[j];
+        if (threadIdx.x == 0)
         {
-            smem[threadIdx.y][threadIdx.x + 1] = src.ptr(i)[j];
-            if (threadIdx.x == 0)
-            {
-                smem[threadIdx.y][0] = src.ptr(i)[max(j - 1, 0)];
-                smem[threadIdx.y][17] = src.ptr(i)[min(j + 16, cols - 1)];
-            }
-            __syncthreads();
-
-            if (j < cols)
-            {
-                dx_buf.ptr(i)[j] = -smem[threadIdx.y][threadIdx.x] + smem[threadIdx.y][threadIdx.x + 2];
-                dy_buf.ptr(i)[j] = smem[threadIdx.y][threadIdx.x] + 2 * smem[threadIdx.y][threadIdx.x + 1] + smem[threadIdx.y][threadIdx.x + 2];
-            }
+            smem[threadIdx.y][0] = src.ptr(i)[::max(j - 1, 0)];
+            smem[threadIdx.y][17] = src.ptr(i)[::min(j + 16, cols - 1)];
         }
-    }
-
-    void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
-
-        calcSobelRowPass<<<grid, block>>>(src, dx_buf, dy_buf, rows, cols);
-        cudaSafeCall( cudaGetLastError() );
-
-        cudaSafeCall(cudaThreadSynchronize());
-    }
-
-    struct L1
-    {
-        static __device__ __forceinline__ float calc(int x, int y)
-        {
-            return abs(x) + abs(y);
-        }
-    };
-    struct L2
-    {
-        static __device__ __forceinline__ float calc(int x, int y)
-        {
-            return sqrtf(x * x + y * y);
-        }
-    };
-
-    template <typename Norm> __global__ void calcMagnitude(const PtrStepi dx_buf, const PtrStepi dy_buf, 
-        PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
-    {
-        __shared__ int sdx[18][16];
-        __shared__ int sdy[18][16];
-
-        const int j = blockIdx.x * blockDim.x + threadIdx.x;
-        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+        __syncthreads();
 
         if (j < cols)
         {
-            sdx[threadIdx.y + 1][threadIdx.x] = dx_buf.ptr(i)[j];
-            sdy[threadIdx.y + 1][threadIdx.x] = dy_buf.ptr(i)[j];
-            if (threadIdx.y == 0)
-            {
-                sdx[0][threadIdx.x] = dx_buf.ptr(max(i - 1, 0))[j];
-                sdx[17][threadIdx.x] = dx_buf.ptr(min(i + 16, rows - 1))[j];
-
-                sdy[0][threadIdx.x] = dy_buf.ptr(max(i - 1, 0))[j];
-                sdy[17][threadIdx.x] = dy_buf.ptr(min(i + 16, rows - 1))[j];
-            }
-            __syncthreads();
-
-            if (i < rows)
-            {
-                int x = sdx[threadIdx.y][threadIdx.x] + 2 * sdx[threadIdx.y + 1][threadIdx.x] + sdx[threadIdx.y + 2][threadIdx.x];
-                int y = -sdy[threadIdx.y][threadIdx.x] + sdy[threadIdx.y + 2][threadIdx.x];
-
-                dx.ptr(i)[j] = x;
-                dy.ptr(i)[j] = y;
-
-                mag.ptr(i + 1)[j + 1] = Norm::calc(x, y);
-            }
+            dx_buf.ptr(i)[j] = -smem[threadIdx.y][threadIdx.x] + smem[threadIdx.y][threadIdx.x + 2];
+            dy_buf.ptr(i)[j] = smem[threadIdx.y][threadIdx.x] + 2 * smem[threadIdx.y][threadIdx.x + 1] + smem[threadIdx.y][threadIdx.x + 2];
         }
     }
+}
 
-    void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+    calcSobelRowPass<<<grid, block>>>(src, dx_buf, dy_buf, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+struct L1
+{
+    static __device__ __forceinline__ float calc(int x, int y)
     {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
-
-        if (L2Grad)
-            calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
-        else
-            calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
-
-        cudaSafeCall( cudaGetLastError() );
-
-        cudaSafeCall(cudaThreadSynchronize());
+        return ::abs(x) + ::abs(y);
     }
-
-    template <typename Norm> __global__ void calcMagnitude(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+};
+struct L2
+{
+    static __device__ __forceinline__ float calc(int x, int y)
     {
-        const int j = blockIdx.x * blockDim.x + threadIdx.x;
-        const int i = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (i < rows && j < cols)
-            mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
+        return ::sqrtf(x * x + y * y);
     }
+};
 
-    void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+template <typename Norm> __global__ void calcMagnitude(const PtrStepi dx_buf, const PtrStepi dy_buf, 
+    PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+{
+    __shared__ int sdx[18][16];
+    __shared__ int sdy[18][16];
+
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (j < cols)
     {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+        sdx[threadIdx.y + 1][threadIdx.x] = dx_buf.ptr(i)[j];
+        sdy[threadIdx.y + 1][threadIdx.x] = dy_buf.ptr(i)[j];
+        if (threadIdx.y == 0)
+        {
+            sdx[0][threadIdx.x] = dx_buf.ptr(::max(i - 1, 0))[j];
+            sdx[17][threadIdx.x] = dx_buf.ptr(::min(i + 16, rows - 1))[j];
 
-        if (L2Grad)
-            calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
-        else
-            calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
+            sdy[0][threadIdx.x] = dy_buf.ptr(::max(i - 1, 0))[j];
+            sdy[17][threadIdx.x] = dy_buf.ptr(::min(i + 16, rows - 1))[j];
+        }
+        __syncthreads();
 
-        cudaSafeCall( cudaGetLastError() );
+        if (i < rows)
+        {
+            int x = sdx[threadIdx.y][threadIdx.x] + 2 * sdx[threadIdx.y + 1][threadIdx.x] + sdx[threadIdx.y + 2][threadIdx.x];
+            int y = -sdy[threadIdx.y][threadIdx.x] + sdy[threadIdx.y + 2][threadIdx.x];
 
-        cudaSafeCall(cudaThreadSynchronize());
+            dx.ptr(i)[j] = x;
+            dy.ptr(i)[j] = y;
+
+            mag.ptr(i + 1)[j + 1] = Norm::calc(x, y);
+        }
     }
+}
+
+void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+    if (L2Grad)
+        calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+    else
+        calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+
+    cudaSafeCall( cudaGetLastError() );
+
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+template <typename Norm> __global__ void calcMagnitude(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols)
+{
+    const int j = blockIdx.x * blockDim.x + threadIdx.x;
+    const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (i < rows && j < cols)
+        mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
+}
+
+void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+    if (L2Grad)
+        calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
+    else
+        calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
+
+    cudaSafeCall( cudaGetLastError() );
+
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////
-        
+    
 #define CANNY_SHIFT 15
 #define TG22        (int)(0.4142135623730950488016887242097*(1<<CANNY_SHIFT) + 0.5)
 
-    __global__ void calcMap(const PtrStepi dx, const PtrStepi dy, const PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+__global__ void calcMap(const PtrStepi dx, const PtrStepi dy, const PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+{
+    __shared__ float smem[18][18];
+
+    const int j = blockIdx.x * 16 + threadIdx.x;
+    const int i = blockIdx.y * 16 + threadIdx.y;
+
+    const int tid = threadIdx.y * 16 + threadIdx.x;
+    const int lx = tid % 18;
+    const int ly = tid / 18;
+
+    if (ly < 14)
+        smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+
+    if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
+        smem[ly + 14][lx] = mag.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
+
+    __syncthreads();
+
+    if (i < rows && j < cols)
     {
-        __shared__ float smem[18][18];
+        int x = dx.ptr(i)[j];
+        int y = dy.ptr(i)[j];
+        const int s = (x ^ y) < 0 ? -1 : 1;
+        const float m = smem[threadIdx.y + 1][threadIdx.x + 1];
 
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
+        x = ::abs(x);
+        y = ::abs(y);
 
-        const int tid = threadIdx.y * 16 + threadIdx.x;
-        const int lx = tid % 18;
-        const int ly = tid / 18;
+        // 0 - the pixel can not belong to an edge
+        // 1 - the pixel might belong to an edge
+        // 2 - the pixel does belong to an edge
+        int edge_type = 0;
 
-        if (ly < 14)
-            smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
-
-        if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
-            smem[ly + 14][lx] = mag.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
-
-        __syncthreads();
-
-        if (i < rows && j < cols)
+        if (m > low_thresh)
         {
-            int x = dx.ptr(i)[j];
-            int y = dy.ptr(i)[j];
-            const int s = (x ^ y) < 0 ? -1 : 1;
-            const float m = smem[threadIdx.y + 1][threadIdx.x + 1];
+            const int tg22x = x * TG22;
+            const int tg67x = tg22x + ((x + x) << CANNY_SHIFT);
 
-            x = abs(x);
-            y = abs(y);
+            y <<= CANNY_SHIFT;
 
-            // 0 - the pixel can not belong to an edge
-            // 1 - the pixel might belong to an edge
-            // 2 - the pixel does belong to an edge
-            int edge_type = 0;
-
-            if (m > low_thresh)
+            if (y < tg22x)
             {
-                const int tg22x = x * TG22;
-                const int tg67x = tg22x + ((x + x) << CANNY_SHIFT);
-
-                y <<= CANNY_SHIFT;
-
-                if (y < tg22x)
-                {
-                    if (m > smem[threadIdx.y + 1][threadIdx.x] && m >= smem[threadIdx.y + 1][threadIdx.x + 2])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
-                else if( y > tg67x )
-                {
-                    if (m > smem[threadIdx.y][threadIdx.x + 1] && m >= smem[threadIdx.y + 2][threadIdx.x + 1])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
-                else
-                {
-                    if (m > smem[threadIdx.y][threadIdx.x + 1 - s] && m > smem[threadIdx.y + 2][threadIdx.x + 1 + s])
-                        edge_type = 1 + (int)(m > high_thresh);
-                }
+                if (m > smem[threadIdx.y + 1][threadIdx.x] && m >= smem[threadIdx.y + 1][threadIdx.x + 2])
+                    edge_type = 1 + (int)(m > high_thresh);
+            }
+            else if( y > tg67x )
+            {
+                if (m > smem[threadIdx.y][threadIdx.x + 1] && m >= smem[threadIdx.y + 2][threadIdx.x + 1])
+                    edge_type = 1 + (int)(m > high_thresh);
+            }
+            else
+            {
+                if (m > smem[threadIdx.y][threadIdx.x + 1 - s] && m > smem[threadIdx.y + 2][threadIdx.x + 1 + s])
+                    edge_type = 1 + (int)(m > high_thresh);
             }
-            
-            map.ptr(i + 1)[j + 1] = edge_type;
         }
+        
+        map.ptr(i + 1)[j + 1] = edge_type;
     }
+}
 
 #undef CANNY_SHIFT
 #undef TG22
 
-    void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
 
-        calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
-        cudaSafeCall( cudaGetLastError() );
+    calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
+    cudaSafeCall( cudaGetLastError() );
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
+    cudaSafeCall(cudaThreadSynchronize());
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-    __device__ unsigned int counter = 0;
+__device__ unsigned int counter = 0;
 
-    __global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
+__global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
+{
+    #if __CUDA_ARCH__ >= 120
+
+    __shared__ int smem[18][18];
+
+    const int j = blockIdx.x * 16 + threadIdx.x;
+    const int i = blockIdx.y * 16 + threadIdx.y;
+
+    const int tid = threadIdx.y * 16 + threadIdx.x;
+    const int lx = tid % 18;
+    const int ly = tid / 18; 
+
+    if (ly < 14)
+        smem[ly][lx] = map.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+
+    if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
+        smem[ly + 14][lx] = map.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
+
+    __syncthreads();
+
+    if (i < rows && j < cols)
     {
-        #if __CUDA_ARCH__ >= 120
+        int n;
 
-        __shared__ int smem[18][18];
-
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
-
-        const int tid = threadIdx.y * 16 + threadIdx.x;
-        const int lx = tid % 18;
-        const int ly = tid / 18; 
-
-        if (ly < 14)
-            smem[ly][lx] = map.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
-
-        if (ly < 4 && blockIdx.y * 16 + ly + 14 <= rows && blockIdx.x * 16 + lx <= cols)
-            smem[ly + 14][lx] = map.ptr(blockIdx.y * 16 + ly + 14)[blockIdx.x * 16 + lx];
-
-        __syncthreads();
-
-        if (i < rows && j < cols)
+        #pragma unroll
+        for (int k = 0; k < 16; ++k)
         {
-            int n;
-
-            #pragma unroll
-            for (int k = 0; k < 16; ++k)
-            {
-                n = 0;
-
-                if (smem[threadIdx.y + 1][threadIdx.x + 1] == 1)
-                {
-                    n += smem[threadIdx.y    ][threadIdx.x    ] == 2;
-                    n += smem[threadIdx.y    ][threadIdx.x + 1] == 2;
-                    n += smem[threadIdx.y    ][threadIdx.x + 2] == 2;
-                    
-                    n += smem[threadIdx.y + 1][threadIdx.x    ] == 2;
-                    n += smem[threadIdx.y + 1][threadIdx.x + 2] == 2;
-                    
-                    n += smem[threadIdx.y + 2][threadIdx.x    ] == 2;
-                    n += smem[threadIdx.y + 2][threadIdx.x + 1] == 2;
-                    n += smem[threadIdx.y + 2][threadIdx.x + 2] == 2;
-                }
-
-                if (n > 0)
-                    smem[threadIdx.y + 1][threadIdx.x + 1] = 2;
-            }
-
-            const int e = smem[threadIdx.y + 1][threadIdx.x + 1];
-
-            map.ptr(i + 1)[j + 1] = e;
-
             n = 0;
 
-            if (e == 2)
+            if (smem[threadIdx.y + 1][threadIdx.x + 1] == 1)
             {
-                n += smem[threadIdx.y    ][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y    ][threadIdx.x + 1] == 1;
-                n += smem[threadIdx.y    ][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y    ][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y    ][threadIdx.x + 1] == 2;
+                n += smem[threadIdx.y    ][threadIdx.x + 2] == 2;
                 
-                n += smem[threadIdx.y + 1][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y + 1][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y + 1][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y + 1][threadIdx.x + 2] == 2;
                 
-                n += smem[threadIdx.y + 2][threadIdx.x    ] == 1;
-                n += smem[threadIdx.y + 2][threadIdx.x + 1] == 1;
-                n += smem[threadIdx.y + 2][threadIdx.x + 2] == 1;
+                n += smem[threadIdx.y + 2][threadIdx.x    ] == 2;
+                n += smem[threadIdx.y + 2][threadIdx.x + 1] == 2;
+                n += smem[threadIdx.y + 2][threadIdx.x + 2] == 2;
             }
 
             if (n > 0)
-            {
-                const unsigned int ind = atomicInc(&counter, (unsigned int)(-1));
-                st[ind] = make_ushort2(j + 1, i + 1);
-            }
+                smem[threadIdx.y + 1][threadIdx.x + 1] = 2;
         }
 
-        #endif
-    }
+        const int e = smem[threadIdx.y + 1][threadIdx.x + 1];
 
-    void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+        map.ptr(i + 1)[j + 1] = e;
 
-        edgesHysteresisLocal<<<grid, block>>>(map, st1, rows, cols);
-        cudaSafeCall( cudaGetLastError() );
+        n = 0;
 
-        cudaSafeCall(cudaThreadSynchronize());
-    }
-
-    __constant__ int c_dx[8] = {-1,  0,  1, -1, 1, -1, 0, 1};
-    __constant__ int c_dy[8] = {-1, -1, -1,  0, 0,  1, 1, 1};
-
-    __global__ void edgesHysteresisGlobal(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols, int count)
-    {
-        #if __CUDA_ARCH__ >= 120
-
-        const int stack_size = 512;
-        
-        __shared__ unsigned int s_counter;
-        __shared__ unsigned int s_ind;
-        __shared__ ushort2 s_st[stack_size];
-
-        if (threadIdx.x == 0)
-            s_counter = 0;
-        __syncthreads();
-
-        int ind = blockIdx.y * gridDim.x + blockIdx.x;
-
-        if (ind < count)
+        if (e == 2)
         {
-            ushort2 pos = st1[ind];
+            n += smem[threadIdx.y    ][threadIdx.x    ] == 1;
+            n += smem[threadIdx.y    ][threadIdx.x + 1] == 1;
+            n += smem[threadIdx.y    ][threadIdx.x + 2] == 1;
+            
+            n += smem[threadIdx.y + 1][threadIdx.x    ] == 1;
+            n += smem[threadIdx.y + 1][threadIdx.x + 2] == 1;
+            
+            n += smem[threadIdx.y + 2][threadIdx.x    ] == 1;
+            n += smem[threadIdx.y + 2][threadIdx.x + 1] == 1;
+            n += smem[threadIdx.y + 2][threadIdx.x + 2] == 1;
+        }
 
-            if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+        if (n > 0)
+        {
+            const unsigned int ind = atomicInc(&counter, (unsigned int)(-1));
+            st[ind] = make_ushort2(j + 1, i + 1);
+        }
+    }
+
+    #endif
+}
+
+void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+    edgesHysteresisLocal<<<grid, block>>>(map, st1, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+__constant__ int c_dx[8] = {-1,  0,  1, -1, 1, -1, 0, 1};
+__constant__ int c_dy[8] = {-1, -1, -1,  0, 0,  1, 1, 1};
+
+__global__ void edgesHysteresisGlobal(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols, int count)
+{
+    #if __CUDA_ARCH__ >= 120
+
+    const int stack_size = 512;
+    
+    __shared__ unsigned int s_counter;
+    __shared__ unsigned int s_ind;
+    __shared__ ushort2 s_st[stack_size];
+
+    if (threadIdx.x == 0)
+        s_counter = 0;
+    __syncthreads();
+
+    int ind = blockIdx.y * gridDim.x + blockIdx.x;
+
+    if (ind < count)
+    {
+        ushort2 pos = st1[ind];
+
+        if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+        {
+            if (threadIdx.x < 8)
             {
-                if (threadIdx.x < 8)
+                pos.x += c_dx[threadIdx.x];
+                pos.y += c_dy[threadIdx.x];
+
+                if (map.ptr(pos.y)[pos.x] == 1)
                 {
-                    pos.x += c_dx[threadIdx.x];
-                    pos.y += c_dy[threadIdx.x];
+                    map.ptr(pos.y)[pos.x] = 2;
+
+                    ind = atomicInc(&s_counter, (unsigned int)(-1));
+
+                    s_st[ind] = pos;
+                }
+            }
+            __syncthreads();
+
+            while (s_counter > 0 && s_counter <= stack_size - blockDim.x)
+            {
+                const int subTaskIdx = threadIdx.x >> 3;
+                const int portion = ::min(s_counter, blockDim.x >> 3);
+
+                pos.x = pos.y = 0;
+
+                if (subTaskIdx < portion)
+                    pos = s_st[s_counter - 1 - subTaskIdx];
+                __syncthreads();
+                    
+                if (threadIdx.x == 0)
+                    s_counter -= portion;
+                __syncthreads();
+                 
+                if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+                {
+                    pos.x += c_dx[threadIdx.x & 7];
+                    pos.y += c_dy[threadIdx.x & 7];
 
                     if (map.ptr(pos.y)[pos.x] == 1)
                     {
@@ -388,103 +419,75 @@ namespace cv { namespace gpu { namespace canny
                     }
                 }
                 __syncthreads();
+            }
 
-                while (s_counter > 0 && s_counter <= stack_size - blockDim.x)
+            if (s_counter > 0)
+            {
+                if (threadIdx.x == 0)
                 {
-                    const int subTaskIdx = threadIdx.x >> 3;
-                    const int portion = min(s_counter, blockDim.x >> 3);
-
-                    pos.x = pos.y = 0;
-
-                    if (subTaskIdx < portion)
-                        pos = s_st[s_counter - 1 - subTaskIdx];
-                    __syncthreads();
-                        
-                    if (threadIdx.x == 0)
-                        s_counter -= portion;
-                    __syncthreads();
-                     
-                    if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
-                    {
-                        pos.x += c_dx[threadIdx.x & 7];
-                        pos.y += c_dy[threadIdx.x & 7];
-
-                        if (map.ptr(pos.y)[pos.x] == 1)
-                        {
-                            map.ptr(pos.y)[pos.x] = 2;
-
-                            ind = atomicInc(&s_counter, (unsigned int)(-1));
-
-                            s_st[ind] = pos;
-                        }
-                    }
-                    __syncthreads();
+                    ind = atomicAdd(&counter, s_counter);
+                    s_ind = ind - s_counter;
                 }
+                __syncthreads();
 
-                if (s_counter > 0)
+                ind = s_ind;
+
+                for (int i = threadIdx.x; i < s_counter; i += blockDim.x)
                 {
-                    if (threadIdx.x == 0)
-                    {
-                        ind = atomicAdd(&counter, s_counter);
-                        s_ind = ind - s_counter;
-                    }
-                    __syncthreads();
-
-                    ind = s_ind;
-
-                    for (int i = threadIdx.x; i < s_counter; i += blockDim.x)
-                    {
-                        st2[ind + i] = s_st[i];
-                    }
+                    st2[ind + i] = s_st[i];
                 }
             }
         }
-
-        #endif
     }
 
-    void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
+    #endif
+}
+
+void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
+{
+    void* counter_ptr;
+    cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, counter) );
+    
+    unsigned int count;
+    cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+
+    while (count > 0)
     {
-        void* counter_ptr;
-        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, "cv::gpu::canny::counter") );
-        
-        unsigned int count;
-        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+        cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
 
-        while (count > 0)
-        {
-            cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
-
-            dim3 block(128, 1, 1);
-            dim3 grid(min(count, 65535u), divUp(count, 65535), 1);
-            edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
-            cudaSafeCall( cudaGetLastError() );
-
-            cudaSafeCall(cudaThreadSynchronize());
-
-            cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
-
-            std::swap(st1, st2);
-        }
-    }
-
-    __global__ void getEdges(PtrStepi map, PtrStepb dst, int rows, int cols)
-    {
-        const int j = blockIdx.x * 16 + threadIdx.x;
-        const int i = blockIdx.y * 16 + threadIdx.y;
-
-        if (i < rows && j < cols)
-            dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
-    }
-
-    void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols)
-    {
-        dim3 block(16, 16, 1);
-        dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
-
-        getEdges<<<grid, block>>>(map, dst, rows, cols);
+        dim3 block(128, 1, 1);
+        dim3 grid(min(count, 65535u), divUp(count, 65535), 1);
+        edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall(cudaThreadSynchronize());
+
+        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+
+        std::swap(st1, st2);
     }
-}}}
+}
+
+__global__ void getEdges(PtrStepi map, PtrStepb dst, int rows, int cols)
+{
+    const int j = blockIdx.x * 16 + threadIdx.x;
+    const int i = blockIdx.y * 16 + threadIdx.y;
+
+    if (i < rows && j < cols)
+        dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
+}
+
+void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols)
+{
+    dim3 block(16, 16, 1);
+    dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+
+    getEdges<<<grid, block>>>(map, dst, rows, cols);
+    cudaSafeCall( cudaGetLastError() );
+
+    cudaSafeCall(cudaThreadSynchronize());
+}
+
+} // namespace canny
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/color.cu

@@ -44,336 +44,337 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/color.hpp"
 
-namespace cv { namespace gpu { namespace device
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_rgba_traits<uchar>::functor_type)
 {
-    template <> struct TransformFunctorTraits<bgra_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+    enum { smart_block_dim_x = 8 };
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgra_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<bgra_to_bgr555_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<rgba_to_bgr555_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgra_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<bgra_to_bgr565_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<rgba_to_bgr565_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr555_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr555_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_bgr565_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_bgr565_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgr555_to_bgra_traits::functor_type> : DefaultTransformFunctorTraits<bgr555_to_bgra_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr555_to_rgba_traits::functor_type> : DefaultTransformFunctorTraits<bgr555_to_rgba_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr565_to_bgra_traits::functor_type> : DefaultTransformFunctorTraits<bgr565_to_bgra_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<bgr565_to_rgba_traits::functor_type> : DefaultTransformFunctorTraits<bgr565_to_rgba_traits::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_bgra_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr555_to_rgba_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_bgra_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgr565_to_rgba_traits::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<gray_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<gray_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<gray_to_bgr555_traits::functor_type> : DefaultTransformFunctorTraits<gray_to_bgr555_traits::functor_type>
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<gray_to_bgr565_traits::functor_type> : DefaultTransformFunctorTraits<gray_to_bgr565_traits::functor_type>
-    {
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr555_traits::functor_type)
+{
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(gray_to_bgr565_traits::functor_type)
+{
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgra_to_yuv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_yuv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_yuv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_yuv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_yuv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_yuv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<yuv4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<yuv4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<yuv4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<yuv4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(yuv4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgra_to_YCrCb4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_YCrCb4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_YCrCb4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_YCrCb4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_YCrCb4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_YCrCb4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<YCrCb4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<YCrCb4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<YCrCb4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<YCrCb4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };    
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(YCrCb4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};    
 
-    template <> struct TransformFunctorTraits<bgra_to_xyz4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_xyz4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_xyz4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_xyz4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_xyz4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_xyz4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<xyz4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<xyz4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<xyz4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<xyz4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(xyz4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgra_to_hsv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_hsv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_hsv4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_hsv4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hsv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hsv4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<hsv4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hsv4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<hsv4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hsv4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hsv4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<bgra_to_hls4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<bgra_to_hls4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<rgba_to_hls4_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<rgba_to_hls4_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(bgra_to_hls4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(rgba_to_hls4_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    template <> struct TransformFunctorTraits<hls4_to_bgra_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hls4_to_bgra_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits<hls4_to_rgba_traits<uchar>::functor_type> : DefaultTransformFunctorTraits<hls4_to_rgba_traits<uchar>::functor_type>
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hls4_to_bgra_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
+DEFINE_TRANSFORM_FUNCTOR_TRAITS(hls4_to_rgba_traits<uchar>::functor_type)
+{
+    enum { smart_block_dim_y = 8 };
+    enum { smart_shift = 4 };
+};
 
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
-        void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream) \
-        { \
-            traits::functor_type functor = traits::create_functor(); \
-            typedef typename traits::functor_type::argument_type src_t; \
-            typedef typename traits::functor_type::result_type   dst_t; \
-            transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, functor, stream); \
-        }
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, traits) \
+    void name(const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream) \
+    { \
+        traits::functor_type functor = traits::create_functor(); \
+        typedef typename traits::functor_type::argument_type src_t; \
+        typedef typename traits::functor_type::result_type   dst_t; \
+        OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<src_t>)src, (DevMem2D_<dst_t>)dst, functor, stream); \
+    }
 
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name, name ## _traits)
 
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _16u, name ## _traits<ushort>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>)
 
-    #define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
-        OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
+#define OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(name) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _8u, name ## _traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _32f, name ## _traits<float>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_8u, name ## _full_traits<uchar>) \
+    OPENCV_GPU_IMPLEMENT_CVTCOLOR(name ## _full_32f, name ## _full_traits<float>)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_rgba)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgb_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgra_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(rgba_to_bgr565)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(gray_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr555)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(gray_to_bgr565)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr555_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE(bgr565_to_gray)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_gray)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_gray)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_yuv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_yuv4)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(yuv4_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_YCrCb4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_YCrCb4)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(YCrCb4_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgb_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(rgba_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgr_to_xyz4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(bgra_to_xyz4)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL(xyz4_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hsv4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hsv4)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hsv4_to_bgra)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls4)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgb_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(rgba_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgr_to_hls4)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(bgra_to_hls4)
 
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgb)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgba)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgra)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgr)
-    OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgb)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_rgba)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls_to_bgra)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgr)
+OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F(hls4_to_bgra)
 
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
-    #undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
-}}}
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ONE
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_ALL
+#undef OPENCV_GPU_IMPLEMENT_CVTCOLOR_8U32F
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/column_filter.cu

@@ -47,8 +47,7 @@
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define MAX_KERNEL_SIZE 16
 #define BLOCK_DIM_X 16
@@ -56,195 +55,195 @@ using namespace cv::gpu::device;
 #define RESULT_STEPS 8
 #define HALO_STEPS 1
 
-namespace filter_column
+namespace column_filter {
+
+__constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+void loadKernel(const float kernel[], int ksize)
 {
-    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+    cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
+}
 
-    void loadKernel(const float kernel[], int ksize)
+template <int KERNEL_SIZE, typename T, typename D, typename B>
+__global__ void linearColumnFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
+{
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+
+    __shared__ T smem[BLOCK_DIM_X][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_Y + 1];
+
+    //Offset to the upper halo edge
+    const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
+    const int y = (blockIdx.y * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_Y + threadIdx.y;
+
+    if (x < src.cols)
     {
-        cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
-    }
+        const T* src_col = src.ptr() + x;
 
-    template <int KERNEL_SIZE, typename T, typename D, typename B>
-    __global__ void linearColumnFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
-    {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+        //Main data
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-        __shared__ T smem[BLOCK_DIM_X][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_Y + 1];
+        //Upper halo
+        #pragma unroll
+        for(int i = 0; i < HALO_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_low(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-        //Offset to the upper halo edge
-        const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
-        const int y = (blockIdx.y * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_Y + threadIdx.y;
+        //Lower halo
+        #pragma unroll
+        for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
+            smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y]=  b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
 
-        if (x < src.cols)
+        __syncthreads();
+
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
         {
-            const T* src_col = src.ptr() + x;
-
-            //Main data
-            #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
-
-            //Upper halo
-            #pragma unroll
-            for(int i = 0; i < HALO_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y] = b.at_low(y + i * BLOCK_DIM_Y, src_col, src.step);
-
-            //Lower halo
-            #pragma unroll
-            for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
-                smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y]=  b.at_high(y + i * BLOCK_DIM_Y, src_col, src.step);
-
-            __syncthreads();
+            sum_t sum = VecTraits<sum_t>::all(0);
 
             #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-            {
-                sum_t sum = VecTraits<sum_t>::all(0);
+            for(int j = 0; j < KERNEL_SIZE; ++j)
+                sum = sum + smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y + j - anchor] * c_kernel[j];
 
-                #pragma unroll
-                for(int j = 0; j < KERNEL_SIZE; ++j)
-                    sum = sum + smem[threadIdx.x][threadIdx.y + i * BLOCK_DIM_Y + j - anchor] * c_kernel[j];
+            int dstY = y + i * BLOCK_DIM_Y;
 
-                int dstY = y + i * BLOCK_DIM_Y;
-
-                if (dstY < src.rows)
-                    dst.ptr(dstY)[x] = saturate_cast<D>(sum);
-            }
+            if (dstY < src.rows)
+                dst.ptr(dstY)[x] = saturate_cast<D>(sum);
         }
     }
 }
 
-namespace cv { namespace gpu { namespace filters
+template <int ksize, typename T, typename D, template<typename> class B>
+void linearColumnFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
+{        
+    const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+    const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, RESULT_STEPS * BLOCK_DIM_Y));
+
+    B<T> b(src.rows);
+
+    linearColumnFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <typename T, typename D>
+void linearColumnFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
 {
-    template <int ksize, typename T, typename D, template<typename> class B>
-    void linearColumnFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
-    {        
-        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-        const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, RESULT_STEPS * BLOCK_DIM_Y));
-
-        B<T> b(src.rows);
-
-        filter_column::linearColumnFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-    template <typename T, typename D>
-    void linearColumnFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
+    static const caller_t callers[5][17] = 
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
-        static const caller_t callers[5][17] = 
         {
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReflect101>,
-                linearColumnFilter_caller<3 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<10, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<11, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<12, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<13, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<14, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<15, T, D, BrdColReflect101>, 
-                linearColumnFilter_caller<16, T, D, BrdColReflect101> 
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReplicate>,
-                linearColumnFilter_caller<3 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<10, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<11, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<12, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<13, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<14, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<15, T, D, BrdColReplicate>, 
-                linearColumnFilter_caller<16, T, D, BrdColReplicate>
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<2 , T, D, BrdColConstant>,
-                linearColumnFilter_caller<3 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<4 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<5 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<6 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<7 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<8 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<9 , T, D, BrdColConstant>, 
-                linearColumnFilter_caller<10, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<11, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<12, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<13, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<14, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<15, T, D, BrdColConstant>, 
-                linearColumnFilter_caller<16, T, D, BrdColConstant> 
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<2 , T, D, BrdColReflect>,
-                linearColumnFilter_caller<3 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<4 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<5 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<6 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<7 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<8 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<9 , T, D, BrdColReflect>, 
-                linearColumnFilter_caller<10, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<11, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<12, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<13, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<14, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<15, T, D, BrdColReflect>, 
-                linearColumnFilter_caller<16, T, D, BrdColReflect>
-            },
-            {
-                0, 
-                linearColumnFilter_caller<1 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<2 , T, D, BrdColWrap>,
-                linearColumnFilter_caller<3 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<4 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<5 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<6 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<7 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<8 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<9 , T, D, BrdColWrap>, 
-                linearColumnFilter_caller<10, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<11, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<12, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<13, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<14, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<15, T, D, BrdColWrap>, 
-                linearColumnFilter_caller<16, T, D, BrdColWrap>,
-            }
-        };
-        
-        filter_column::loadKernel(kernel, ksize);
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReflect101>,
+            linearColumnFilter_caller<3 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<10, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<11, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<12, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<13, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<14, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<15, T, D, BrdColReflect101>, 
+            linearColumnFilter_caller<16, T, D, BrdColReflect101> 
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReplicate>,
+            linearColumnFilter_caller<3 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<10, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<11, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<12, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<13, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<14, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<15, T, D, BrdColReplicate>, 
+            linearColumnFilter_caller<16, T, D, BrdColReplicate>
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<2 , T, D, BrdColConstant>,
+            linearColumnFilter_caller<3 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<4 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<5 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<6 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<7 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<8 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<9 , T, D, BrdColConstant>, 
+            linearColumnFilter_caller<10, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<11, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<12, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<13, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<14, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<15, T, D, BrdColConstant>, 
+            linearColumnFilter_caller<16, T, D, BrdColConstant> 
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<2 , T, D, BrdColReflect>,
+            linearColumnFilter_caller<3 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<4 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<5 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<6 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<7 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<8 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<9 , T, D, BrdColReflect>, 
+            linearColumnFilter_caller<10, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<11, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<12, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<13, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<14, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<15, T, D, BrdColReflect>, 
+            linearColumnFilter_caller<16, T, D, BrdColReflect>
+        },
+        {
+            0, 
+            linearColumnFilter_caller<1 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<2 , T, D, BrdColWrap>,
+            linearColumnFilter_caller<3 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<4 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<5 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<6 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<7 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<8 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<9 , T, D, BrdColWrap>, 
+            linearColumnFilter_caller<10, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<11, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<12, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<13, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<14, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<15, T, D, BrdColWrap>, 
+            linearColumnFilter_caller<16, T, D, BrdColWrap>,
+        }
+    };
+    
+    loadKernel(kernel, ksize);
 
-        callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
-    }
+    callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
+}
 
-    template void linearColumnFilter_gpu<float , uchar >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float4, uchar4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearColumnFilter_gpu<float , short >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearColumnFilter_gpu<float2, short2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float3, short3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float , int   >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearColumnFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-}}}
+template void linearColumnFilter_gpu<float , uchar >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float4, uchar4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearColumnFilter_gpu<float , short >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearColumnFilter_gpu<float2, short2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float3, short3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float , int   >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearColumnFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+
+} // namespace column_filter
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/copy_make_border.cu

@@ -43,85 +43,87 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace copy_make_border {
+
+template <typename Ptr2D, typename T> __global__ void copyMakeBorder(const Ptr2D src, DevMem2D_<T> dst, int top, int left)
 {
-    template <typename Ptr2D, typename T> __global__ void copyMakeBorder(const Ptr2D src, DevMem2D_<T> dst, int top, int left)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
 
-        if (x < dst.cols && y < dst.rows)
-            dst.ptr(y)[x] = src(y - top, x - left);
+    if (x < dst.cols && y < dst.rows)
+        dst.ptr(y)[x] = src(y - top, x - left);
+}
+
+template <template <typename> class B, typename T> struct CopyMakeBorderDispatcher
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, int top, int left, 
+        const typename VecTraits<T>::elem_type* borderValue, cudaStream_t stream)
+    {        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+
+        B<T> brd(src.rows, src.cols, VecTraits<T>::make(borderValue));
+        BorderReader< PtrStep<T>, B<T> > brdSrc(src, brd);
+
+        copyMakeBorder<<<grid, block, 0, stream>>>(brdSrc, dst, top, left);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
     }
+};
 
-    template <template <typename> class B, typename T> struct CopyMakeBorderDispatcher
+template <typename T, int cn> void copyMakeBorder_gpu(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, 
+    const T* borderValue, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type vec_type;
+
+    typedef void (*caller_t)(const DevMem2D_<vec_type>& src, const DevMem2D_<vec_type>& dst, int top, int left, const T* borderValue, cudaStream_t stream);
+
+    static const caller_t callers[5] = 
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, int top, int left, 
-            const typename VecTraits<T>::elem_type* borderValue, cudaStream_t stream)
-        {        
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
-
-            B<T> brd(src.rows, src.cols, VecTraits<T>::make(borderValue));
-            BorderReader< PtrStep<T>, B<T> > brdSrc(src, brd);
-
-            copyMakeBorder<<<grid, block, 0, stream>>>(brdSrc, dst, top, left);
-            cudaSafeCall( cudaGetLastError() );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
+        CopyMakeBorderDispatcher<BrdReflect101, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdReplicate, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdConstant, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdReflect, vec_type>::call, 
+        CopyMakeBorderDispatcher<BrdWrap, vec_type>::call 
     };
 
-    template <typename T, int cn> void copyMakeBorder_gpu(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, 
-        const T* borderValue, cudaStream_t stream)
-    {
-        typedef typename TypeVec<T, cn>::vec_type vec_type;
+    callers[borderMode](DevMem2D_<vec_type>(src), DevMem2D_<vec_type>(dst), top, left, borderValue, stream);
+}
 
-        typedef void (*caller_t)(const DevMem2D_<vec_type>& src, const DevMem2D_<vec_type>& dst, int top, int left, const T* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
 
-        static const caller_t callers[5] = 
-        {
-            CopyMakeBorderDispatcher<BrdReflect101, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdReplicate, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdConstant, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdReflect, vec_type>::call, 
-            CopyMakeBorderDispatcher<BrdWrap, vec_type>::call 
-        };
+//template void copyMakeBorder_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
 
-        callers[borderMode](DevMem2D_<vec_type>(src), DevMem2D_<vec_type>(dst), top, left, borderValue, stream);
-    }
+template void copyMakeBorder_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
 
-    template void copyMakeBorder_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const uchar* borderValue, cudaStream_t stream);
-    
-    //template void copyMakeBorder_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const schar* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const ushort* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
-    
-    //template void copyMakeBorder_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
-    
-    template void copyMakeBorder_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    //template void copyMakeBorder_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-    template void copyMakeBorder_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
-}}}
+template void copyMakeBorder_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const short* borderValue, cudaStream_t stream);
+
+//template void copyMakeBorder_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const int* borderValue, cudaStream_t stream);
+
+template void copyMakeBorder_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+//template void copyMakeBorder_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+template void copyMakeBorder_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int top, int left, int borderMode, const float* borderValue, cudaStream_t stream);
+
+} // namespace copy_make_border
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/hist.cu

@@ -45,9 +45,7 @@
 #include "opencv2/gpu/device/utility.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define UINT_BITS 32U
 
@@ -67,154 +65,157 @@ using namespace cv::gpu::device;
 
 #define USE_SMEM_ATOMICS (__CUDA_ARCH__ >= 120)
 
-namespace cv { namespace gpu { namespace histograms
+namespace hist {
+
+#if (!USE_SMEM_ATOMICS)
+
+    #define TAG_MASK ( (1U << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE)) - 1U )
+
+    __forceinline__ __device__ void addByte(volatile uint* s_WarpHist, uint data, uint threadTag)
+    {
+        uint count;
+        do
+        {
+            count = s_WarpHist[data] & TAG_MASK;
+            count = threadTag | (count + 1);
+            s_WarpHist[data] = count;
+        } while (s_WarpHist[data] != count);
+    }
+
+#else
+
+    #define TAG_MASK 0xFFFFFFFFU
+
+    __forceinline__ __device__ void addByte(uint* s_WarpHist, uint data, uint threadTag)
+    {
+        atomicAdd(s_WarpHist + data, 1);
+    }
+
+#endif
+
+__forceinline__ __device__ void addWord(uint* s_WarpHist, uint data, uint tag, uint pos_x, uint cols)
 {
-    #if (!USE_SMEM_ATOMICS)
+    uint x = pos_x << 2;
 
-        #define TAG_MASK ( (1U << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE)) - 1U )
+    if (x + 0 < cols) addByte(s_WarpHist, (data >>  0) & 0xFFU, tag);
+    if (x + 1 < cols) addByte(s_WarpHist, (data >>  8) & 0xFFU, tag);
+    if (x + 2 < cols) addByte(s_WarpHist, (data >> 16) & 0xFFU, tag);
+    if (x + 3 < cols) addByte(s_WarpHist, (data >> 24) & 0xFFU, tag);
+}
 
-        __forceinline__ __device__ void addByte(volatile uint* s_WarpHist, uint data, uint threadTag)
-        {
-            uint count;
-            do
-            {
-                count = s_WarpHist[data] & TAG_MASK;
-                count = threadTag | (count + 1);
-                s_WarpHist[data] = count;
-            } while (s_WarpHist[data] != count);
-        }
+__global__ void histogram256(const PtrStep<uint> d_Data, uint* d_PartialHistograms, uint dataCount, uint cols)
+{
+    //Per-warp subhistogram storage
+    __shared__ uint s_Hist[HISTOGRAM256_THREADBLOCK_MEMORY];
+    uint* s_WarpHist= s_Hist + (threadIdx.x >> OPENCV_GPU_LOG_WARP_SIZE) * HISTOGRAM256_BIN_COUNT;
 
-    #else
+    //Clear shared memory storage for current threadblock before processing
+    #pragma unroll
+    for (uint i = 0; i < (HISTOGRAM256_THREADBLOCK_MEMORY / HISTOGRAM256_THREADBLOCK_SIZE); i++)
+       s_Hist[threadIdx.x + i * HISTOGRAM256_THREADBLOCK_SIZE] = 0;
 
-        #define TAG_MASK 0xFFFFFFFFU
+    //Cycle through the entire data set, update subhistograms for each warp
+    const uint tag = threadIdx.x << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE);
 
-        __forceinline__ __device__ void addByte(uint* s_WarpHist, uint data, uint threadTag)
-        {
-            atomicAdd(s_WarpHist + data, 1);
-        }
-
-    #endif
-
-    __forceinline__ __device__ void addWord(uint* s_WarpHist, uint data, uint tag, uint pos_x, uint cols)
+    __syncthreads();
+    const uint colsui = d_Data.step / sizeof(uint);
+    for(uint pos = blockIdx.x * blockDim.x + threadIdx.x; pos < dataCount; pos += blockDim.x * gridDim.x)
     {
-        uint x = pos_x << 2;
-
-        if (x + 0 < cols) addByte(s_WarpHist, (data >>  0) & 0xFFU, tag);
-        if (x + 1 < cols) addByte(s_WarpHist, (data >>  8) & 0xFFU, tag);
-        if (x + 2 < cols) addByte(s_WarpHist, (data >> 16) & 0xFFU, tag);
-        if (x + 3 < cols) addByte(s_WarpHist, (data >> 24) & 0xFFU, tag);
+        uint pos_y = pos / colsui;
+        uint pos_x = pos % colsui;
+        uint data = d_Data.ptr(pos_y)[pos_x];
+        addWord(s_WarpHist, data, tag, pos_x, cols);
     }
 
-    __global__ void histogram256(const PtrStep<uint> d_Data, uint* d_PartialHistograms, uint dataCount, uint cols)
-    {
-        //Per-warp subhistogram storage
-        __shared__ uint s_Hist[HISTOGRAM256_THREADBLOCK_MEMORY];
-        uint* s_WarpHist= s_Hist + (threadIdx.x >> OPENCV_GPU_LOG_WARP_SIZE) * HISTOGRAM256_BIN_COUNT;
-
-        //Clear shared memory storage for current threadblock before processing
-        #pragma unroll
-        for (uint i = 0; i < (HISTOGRAM256_THREADBLOCK_MEMORY / HISTOGRAM256_THREADBLOCK_SIZE); i++)
-           s_Hist[threadIdx.x + i * HISTOGRAM256_THREADBLOCK_SIZE] = 0;
-
-        //Cycle through the entire data set, update subhistograms for each warp
-        const uint tag = threadIdx.x << (UINT_BITS - OPENCV_GPU_LOG_WARP_SIZE);
-
-        __syncthreads();
-        const uint colsui = d_Data.step / sizeof(uint);
-        for(uint pos = blockIdx.x * blockDim.x + threadIdx.x; pos < dataCount; pos += blockDim.x * gridDim.x)
-        {
-            uint pos_y = pos / colsui;
-            uint pos_x = pos % colsui;
-            uint data = d_Data.ptr(pos_y)[pos_x];
-            addWord(s_WarpHist, data, tag, pos_x, cols);
-        }
-
-        //Merge per-warp histograms into per-block and write to global memory
-        __syncthreads();
-        for(uint bin = threadIdx.x; bin < HISTOGRAM256_BIN_COUNT; bin += HISTOGRAM256_THREADBLOCK_SIZE)
-        {
-            uint sum = 0;
-
-            for (uint i = 0; i < WARP_COUNT; i++)
-                sum += s_Hist[bin + i * HISTOGRAM256_BIN_COUNT] & TAG_MASK;
-
-            d_PartialHistograms[blockIdx.x * HISTOGRAM256_BIN_COUNT + bin] = sum;
-        }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////////
-    // Merge histogram256() output
-    // Run one threadblock per bin; each threadblock adds up the same bin counter
-    // from every partial histogram. Reads are uncoalesced, but mergeHistogram256
-    // takes only a fraction of total processing time
-    ////////////////////////////////////////////////////////////////////////////////
-
-    __global__ void mergeHistogram256(const uint* d_PartialHistograms, int* d_Histogram)
+    //Merge per-warp histograms into per-block and write to global memory
+    __syncthreads();
+    for(uint bin = threadIdx.x; bin < HISTOGRAM256_BIN_COUNT; bin += HISTOGRAM256_THREADBLOCK_SIZE)
     {
         uint sum = 0;
 
-        #pragma unroll
-        for (uint i = threadIdx.x; i < PARTIAL_HISTOGRAM256_COUNT; i += MERGE_THREADBLOCK_SIZE)
-            sum += d_PartialHistograms[blockIdx.x + i * HISTOGRAM256_BIN_COUNT];
+        for (uint i = 0; i < WARP_COUNT; i++)
+            sum += s_Hist[bin + i * HISTOGRAM256_BIN_COUNT] & TAG_MASK;
 
-        __shared__ uint data[MERGE_THREADBLOCK_SIZE];
-        data[threadIdx.x] = sum;
-
-        for (uint stride = MERGE_THREADBLOCK_SIZE / 2; stride > 0; stride >>= 1)
-        {
-            __syncthreads();
-            if(threadIdx.x < stride)
-                data[threadIdx.x] += data[threadIdx.x + stride];
-        }
-
-        if(threadIdx.x == 0)
-            d_Histogram[blockIdx.x] = saturate_cast<int>(data[0]);
+        d_PartialHistograms[blockIdx.x * HISTOGRAM256_BIN_COUNT + bin] = sum;
     }
+}
 
-    void histogram256_gpu(DevMem2Db src, int* hist, uint* buf, cudaStream_t stream)
+////////////////////////////////////////////////////////////////////////////////
+// Merge histogram256() output
+// Run one threadblock per bin; each threadblock adds up the same bin counter
+// from every partial histogram. Reads are uncoalesced, but mergeHistogram256
+// takes only a fraction of total processing time
+////////////////////////////////////////////////////////////////////////////////
+
+__global__ void mergeHistogram256(const uint* d_PartialHistograms, int* d_Histogram)
+{
+    uint sum = 0;
+
+    #pragma unroll
+    for (uint i = threadIdx.x; i < PARTIAL_HISTOGRAM256_COUNT; i += MERGE_THREADBLOCK_SIZE)
+        sum += d_PartialHistograms[blockIdx.x + i * HISTOGRAM256_BIN_COUNT];
+
+    __shared__ uint data[MERGE_THREADBLOCK_SIZE];
+    data[threadIdx.x] = sum;
+
+    for (uint stride = MERGE_THREADBLOCK_SIZE / 2; stride > 0; stride >>= 1)
     {
-        histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
-            DevMem2D_<uint>(src),
-            buf, 
-            static_cast<uint>(src.rows * src.step / sizeof(uint)),
-            src.cols);
-
-        cudaSafeCall( cudaGetLastError() );
-
-        mergeHistogram256<<<HISTOGRAM256_BIN_COUNT, MERGE_THREADBLOCK_SIZE, 0, stream>>>(buf, hist);
-
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        __syncthreads();
+        if(threadIdx.x < stride)
+            data[threadIdx.x] += data[threadIdx.x + stride];
     }
 
-    __constant__ int c_lut[256];
+    if(threadIdx.x == 0)
+        d_Histogram[blockIdx.x] = saturate_cast<int>(data[0]);
+}
 
-    __global__ void equalizeHist(const DevMem2Db src, PtrStepb dst)
+void histogram256_gpu(DevMem2Db src, int* hist, uint* buf, cudaStream_t stream)
+{
+    histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
+        DevMem2D_<uint>(src),
+        buf, 
+        static_cast<uint>(src.rows * src.step / sizeof(uint)),
+        src.cols);
+
+    cudaSafeCall( cudaGetLastError() );
+
+    mergeHistogram256<<<HISTOGRAM256_BIN_COUNT, MERGE_THREADBLOCK_SIZE, 0, stream>>>(buf, hist);
+
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+__constant__ int c_lut[256];
+
+__global__ void equalizeHist(const DevMem2Db src, PtrStepb dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (x < src.cols && y < src.rows)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (x < src.cols && y < src.rows)
-        {
-            const uchar val = src.ptr(y)[x];
-            const int lut = c_lut[val];
-            dst.ptr(y)[x] = __float2int_rn(255.0f / (src.cols * src.rows) * lut);
-        }
+        const uchar val = src.ptr(y)[x];
+        const int lut = c_lut[val];
+        dst.ptr(y)[x] = __float2int_rn(255.0f / (src.cols * src.rows) * lut);
     }
+}
 
-    void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream)
-    {
-        dim3 block(16, 16);
-        dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+void equalizeHist_gpu(DevMem2Db src, DevMem2Db dst, const int* lut, cudaStream_t stream)
+{
+    dim3 block(16, 16);
+    dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
 
-        cudaSafeCall( cudaMemcpyToSymbol(cv::gpu::histograms::c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
+    cudaSafeCall( cudaMemcpyToSymbol(c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
 
-        equalizeHist<<<grid, block, 0, stream>>>(src, dst);
-        cudaSafeCall( cudaGetLastError() );
+    equalizeHist<<<grid, block, 0, stream>>>(src, dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-}}}
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+} // namespace hist
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/hog.cu

@@ -42,13 +42,15 @@
 
 #include "internal_shared.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
 // Other values are not supported
 #define CELL_WIDTH 8
 #define CELL_HEIGHT 8
 #define CELLS_PER_BLOCK_X 2
 #define CELLS_PER_BLOCK_Y 2
 
-namespace cv { namespace gpu { namespace hog {
+namespace hog {
 
 __constant__ int cnbins;
 __constant__ int cblock_stride_x;
@@ -83,23 +85,23 @@ int power_2up(unsigned int n)
 void set_up_constants(int nbins, int block_stride_x, int block_stride_y, 
                       int nblocks_win_x, int nblocks_win_y)
 {
-    uploadConstant("cv::gpu::hog::cnbins", nbins);
-    uploadConstant("cv::gpu::hog::cblock_stride_x", block_stride_x);
-    uploadConstant("cv::gpu::hog::cblock_stride_y", block_stride_y);
-    uploadConstant("cv::gpu::hog::cnblocks_win_x", nblocks_win_x);
-    uploadConstant("cv::gpu::hog::cnblocks_win_y", nblocks_win_y);
+    cudaSafeCall( cudaMemcpyToSymbol(cnbins, &nbins, sizeof(nbins)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_stride_x, &block_stride_x, sizeof(block_stride_x)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_stride_y, &block_stride_y, sizeof(block_stride_y)) ); 
+    cudaSafeCall( cudaMemcpyToSymbol(cnblocks_win_x, &nblocks_win_x, sizeof(nblocks_win_x)) );  
+    cudaSafeCall( cudaMemcpyToSymbol(cnblocks_win_y, &nblocks_win_y, sizeof(nblocks_win_y)) ); 
 
-    int block_hist_size = nbins * CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y;
-    uploadConstant("cv::gpu::hog::cblock_hist_size", block_hist_size);
+    int block_hist_size = nbins * CELLS_PER_BLOCK_X * CELLS_PER_BLOCK_Y; 
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_hist_size, &block_hist_size, sizeof(block_hist_size)) ); 
 
-    int block_hist_size_2up = power_2up(block_hist_size);    
-    uploadConstant("cv::gpu::hog::cblock_hist_size_2up", block_hist_size_2up);
+    int block_hist_size_2up = power_2up(block_hist_size);  
+    cudaSafeCall( cudaMemcpyToSymbol(cblock_hist_size_2up, &block_hist_size_2up, sizeof(block_hist_size_2up)) );
 
     int descr_width = nblocks_win_x * block_hist_size;
-    uploadConstant("cv::gpu::hog::cdescr_width", descr_width);
+    cudaSafeCall( cudaMemcpyToSymbol(cdescr_width, &descr_width, sizeof(descr_width)) );
 
     int descr_size = descr_width * nblocks_win_y;
-    uploadConstant("cv::gpu::hog::cdescr_size", descr_size);
+    cudaSafeCall( cudaMemcpyToSymbol(cdescr_size, &descr_size, sizeof(descr_size)) );
 }
 
 
@@ -153,10 +155,10 @@ __global__ void compute_hists_kernel_many_blocks(const int img_block_width, cons
             int dist_center_y = dist_y - 4 * (1 - 2 * cell_y);
             int dist_center_x = dist_x - 4 * (1 - 2 * cell_x);
 
-            float gaussian = expf(-(dist_center_y * dist_center_y + 
-                                    dist_center_x * dist_center_x) * scale);
-            float interp_weight = (8.f - fabs(dist_y + 0.5f)) * 
-                                  (8.f - fabs(dist_x + 0.5f)) / 64.f;
+            float gaussian = ::expf(-(dist_center_y * dist_center_y + 
+                                      dist_center_x * dist_center_x) * scale);
+            float interp_weight = (8.f - ::fabs(dist_y + 0.5f)) * 
+                                  (8.f - ::fabs(dist_x + 0.5f)) / 64.f;
 
             hist[bin.x * 48 * nblocks] += gaussian * interp_weight * vote.x;
             hist[bin.y * 48 * nblocks] += gaussian * interp_weight * vote.y;
@@ -273,15 +275,15 @@ __global__ void normalize_hists_kernel_many_blocks(const int block_hist_size,
     __syncthreads();
     float sum = reduce_smem<nthreads>(squares);
     
-    float scale = 1.0f / (sqrtf(sum) + 0.1f * block_hist_size);        
-    elem = min(elem * scale, threshold);
+    float scale = 1.0f / (::sqrtf(sum) + 0.1f * block_hist_size);        
+    elem = ::min(elem * scale, threshold);
     
     __syncthreads();
     squares[threadIdx.x] = elem * elem;
 
     __syncthreads();
     sum = reduce_smem<nthreads>(squares);
-    scale = 1.0f / (sqrtf(sum) + 1e-3f);
+    scale = 1.0f / (::sqrtf(sum) + 1e-3f);
     
     if (threadIdx.x < block_hist_size)
         hist[0] = elem * scale;
@@ -533,7 +535,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
     if (threadIdx.x == 0)
     {
-        val = row[max(x - 1, 1)];
+        val = row[::max(x - 1, 1)];
         sh_row[0] = val.x;
         sh_row[(nthreads + 2)] = val.y;
         sh_row[2 * (nthreads + 2)] = val.z;
@@ -541,7 +543,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
     if (threadIdx.x == blockDim.x - 1)
     {
-        val = row[min(x + 1, width - 2)];
+        val = row[::min(x + 1, width - 2)];
         sh_row[blockDim.x + 1] = val.x;
         sh_row[blockDim.x + 1 + (nthreads + 2)] = val.y;
         sh_row[blockDim.x + 1 + 2 * (nthreads + 2)] = val.z;
@@ -561,7 +563,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
 
         float3 dx;
         if (correct_gamma)
-            dx = make_float3(sqrtf(b.x) - sqrtf(a.x), sqrtf(b.y) - sqrtf(a.y), sqrtf(b.z) - sqrtf(a.z));    
+            dx = make_float3(::sqrtf(b.x) - ::sqrtf(a.x), ::sqrtf(b.y) - ::sqrtf(a.y), ::sqrtf(b.z) - ::sqrtf(a.z));    
         else
             dx = make_float3(b.x - a.x, b.y - a.y, b.z - a.z);    
 
@@ -576,7 +578,7 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
             b = make_float3(val.x, val.y, val.z);
 
             if (correct_gamma)
-                dy = make_float3(sqrtf(b.x) - sqrtf(a.x), sqrtf(b.y) - sqrtf(a.y), sqrtf(b.z) - sqrtf(a.z));
+                dy = make_float3(::sqrtf(b.x) - ::sqrtf(a.x), ::sqrtf(b.y) - ::sqrtf(a.y), ::sqrtf(b.z) - ::sqrtf(a.z));
             else
                 dy = make_float3(b.x - a.x, b.y - a.y, b.z - a.z);
         }
@@ -601,10 +603,10 @@ __global__ void compute_gradients_8UC4_kernel(int height, int width, const PtrEl
             mag0 = mag1;
         }
 
-        mag0 = sqrtf(mag0);
+        mag0 = ::sqrtf(mag0);
 
-        float ang = (atan2f(best_dy, best_dx) + CV_PI_F) * angle_scale - 0.5f;
-        int hidx = (int)floorf(ang);
+        float ang = (::atan2f(best_dy, best_dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)::floorf(ang);
         ang -= hidx;
         hidx = (hidx + cnbins) % cnbins;
 
@@ -648,10 +650,10 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
         sh_row[threadIdx.x + 1] = row[width - 2];
 
     if (threadIdx.x == 0)
-        sh_row[0] = row[max(x - 1, 1)];
+        sh_row[0] = row[::max(x - 1, 1)];
 
     if (threadIdx.x == blockDim.x - 1)
-        sh_row[blockDim.x + 1] = row[min(x + 1, width - 2)];
+        sh_row[blockDim.x + 1] = row[::min(x + 1, width - 2)];
 
     __syncthreads();
     if (x < width)
@@ -659,7 +661,7 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
         float dx;
 
         if (correct_gamma)
-            dx = sqrtf(sh_row[threadIdx.x + 2]) - sqrtf(sh_row[threadIdx.x]);
+            dx = ::sqrtf(sh_row[threadIdx.x + 2]) - ::sqrtf(sh_row[threadIdx.x]);
         else
             dx = sh_row[threadIdx.x + 2] - sh_row[threadIdx.x];
 
@@ -669,14 +671,14 @@ __global__ void compute_gradients_8UC1_kernel(int height, int width, const PtrEl
             float a = ((const unsigned char*)img.ptr(blockIdx.y + 1))[x];
             float b = ((const unsigned char*)img.ptr(blockIdx.y - 1))[x];
             if (correct_gamma)
-                dy = sqrtf(a) - sqrtf(b);
+                dy = ::sqrtf(a) - ::sqrtf(b);
             else
                 dy = a - b;
         }
-        float mag = sqrtf(dx * dx + dy * dy);
+        float mag = ::sqrtf(dx * dx + dy * dy);
 
-        float ang = (atan2f(dy, dx) + CV_PI_F) * angle_scale - 0.5f;
-        int hidx = (int)floorf(ang);
+        float ang = (::atan2f(dy, dx) + CV_PI_F) * angle_scale - 0.5f;
+        int hidx = (int)::floorf(ang);
         ang -= hidx;
         hidx = (hidx + cnbins) % cnbins;
 
@@ -768,4 +770,6 @@ static void resize_for_hog(const DevMem2Db& src, DevMem2Db dst, TEX& tex)
 void resize_8UC1(const DevMem2Db& src, DevMem2Db dst) { resize_for_hog<uchar> (src, dst, resize8UC1_tex); }
 void resize_8UC4(const DevMem2Db& src, DevMem2Db dst) { resize_for_hog<uchar4>(src, dst, resize8UC4_tex); }
 
-}}}
+} // namespace hog 
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/internal_shared.hpp

@@ -43,11 +43,15 @@
 #ifndef __OPENCV_internal_shared_HPP__
 #define __OPENCV_internal_shared_HPP__
 
+#include <cuda_runtime.h>
+#include <npp.h>
+#include "NPP_staging.hpp"
 #include "opencv2/gpu/devmem2d.hpp"
 #include "safe_call.hpp"
-#include "cuda_runtime.h"
-#include "npp.h"
-#include "NPP_staging.hpp"
+
+#ifndef CV_PI
+#define CV_PI   3.1415926535897932384626433832795f
+#endif
 
 #ifndef CV_PI_F
   #ifndef CV_PI
@@ -57,146 +61,158 @@
   #endif
 #endif
 
-namespace cv
+#define BEGIN_OPENCV_DEVICE_NAMESPACE namespace cv { namespace gpu { namespace device { 
+#define END_OPENCV_DEVICE_NAMESPACE   }}}
+#define OPENCV_DEVICE_NAMESPACE       ::cv::gpu::device
+#define OPENCV_DEVICE_NAMESPACE_      ::cv::gpu::device:: 
+
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef signed char schar;
+typedef unsigned int uint;
+
+template<class T> static inline void bindTexture(const textureReference* tex, const DevMem2D_<T>& img)
 {
-    namespace gpu
-    {
-        typedef unsigned char uchar;
-        typedef signed char schar;
-        typedef unsigned short ushort;
-        typedef unsigned int uint;       
-
-        enum 
-        {
-            BORDER_REFLECT101_GPU = 0,
-            BORDER_REPLICATE_GPU,
-            BORDER_CONSTANT_GPU,
-            BORDER_REFLECT_GPU,
-            BORDER_WRAP_GPU
-        };
-                
-        // Converts CPU border extrapolation mode into GPU internal analogue.
-        // Returns true if the GPU analogue exists, false otherwise.
-        bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
-
-        static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
-
-        template<class T> static inline void uploadConstant(const char* name, const T& value) 
-        { 
-            cudaSafeCall( cudaMemcpyToSymbol(name, &value, sizeof(T)) ); 
-        }
-
-        template<class T> static inline void uploadConstant(const char* name, const T& value, cudaStream_t stream) 
-        {
-            cudaSafeCall( cudaMemcpyToSymbolAsync(name, &value, sizeof(T), 0, cudaMemcpyHostToDevice, stream) ); 
-        }        
-
-        template<class T> static inline void bindTexture(const char* name, const DevMem2D_<T>& img/*, bool normalized = false,
-            enum cudaTextureFilterMode filterMode = cudaFilterModePoint, enum cudaTextureAddressMode addrMode = cudaAddressModeClamp*/)
-        {            
-            //!!!! const_cast is disabled!
-            //!!!! Please use constructor of 'class texture'  instead.
-
-            //textureReference* tex; 
-            //cudaSafeCall( cudaGetTextureReference((const textureReference**)&tex, name) ); 
-            //tex->normalized = normalized;
-            //tex->filterMode = filterMode;
-            //tex->addressMode[0] = addrMode;
-            //tex->addressMode[1] = addrMode;
-            
-            const textureReference* tex; 
-            cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
-
-            cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
-            cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
-        }
-
-        static inline void unbindTexture(const char *name)
-        {
-            const textureReference* tex; 
-            cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
-            cudaSafeCall( cudaUnbindTexture(tex) );
-        }
-
-        class TextureBinder
-        {
-        public:
-            TextureBinder() : tex_(0) {}
-            template <typename T> TextureBinder(const textureReference* tex, const DevMem2D_<T>& img) : tex_(0)
-            {
-                bind(tex, img);
-            }
-            template <typename T> TextureBinder(const char* tex_name, const DevMem2D_<T>& img) : tex_(0)
-            {
-                bind(tex_name, img);
-            }
-            ~TextureBinder() { unbind(); }
-
-            template <typename T> void bind(const textureReference* tex, const DevMem2D_<T>& img)
-            {
-                unbind();
-
-                cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
-                cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
-
-                tex_ = tex;
-            }
-            template <typename T> void bind(const char* tex_name, const DevMem2D_<T>& img)
-            {
-                const textureReference* tex; 
-                cudaSafeCall( cudaGetTextureReference(&tex, tex_name) ); 
-                bind(tex, img);
-            }
-
-            void unbind()
-            {
-                if (tex_)
-                {
-                    cudaUnbindTexture(tex_);
-                    tex_ = 0;
-                }
-            }
-
-        private:
-            const textureReference* tex_;
-        };
-
-        class NppStreamHandler
-        {
-        public:
-            inline explicit NppStreamHandler(cudaStream_t newStream = 0)
-            {
-                oldStream = nppGetStream();
-                nppSetStream(newStream);
-            }
-
-            inline ~NppStreamHandler()
-            {
-                nppSetStream(oldStream);
-            }
-
-        private:
-            cudaStream_t oldStream;
-        };
-
-        class NppStStreamHandler
-        {
-        public:
-            inline explicit NppStStreamHandler(cudaStream_t newStream = 0)
-            {
-                oldStream = nppStSetActiveCUDAstream(newStream);
-            }
-
-            inline ~NppStStreamHandler()
-            {
-                nppStSetActiveCUDAstream(oldStream);
-            }
-
-        private:
-            cudaStream_t oldStream;
-        };
-    }
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
 }
 
+END_OPENCV_DEVICE_NAMESPACE
+
+namespace cv { namespace gpu 
+{
+    enum 
+    {
+        BORDER_REFLECT101_GPU = 0,
+        BORDER_REPLICATE_GPU,
+        BORDER_CONSTANT_GPU,
+        BORDER_REFLECT_GPU,
+        BORDER_WRAP_GPU
+    };
+            
+    // Converts CPU border extrapolation mode into GPU internal analogue.
+    // Returns true if the GPU analogue exists, false otherwise.
+    bool tryConvertToGpuBorderType(int cpuBorderType, int& gpuBorderType);
+
+    static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
+
+    /*template<class T> static inline void uploadConstant(const char* name, const T& value) 
+    { 
+        cudaSafeCall( cudaMemcpyToSymbol(name, &value, sizeof(T)) ); 
+    }
+
+    template<class T> static inline void uploadConstant(const char* name, const T& value, cudaStream_t stream) 
+    {
+        cudaSafeCall( cudaMemcpyToSymbolAsync(name, &value, sizeof(T), 0, cudaMemcpyHostToDevice, stream) ); 
+    }   */     
+
+    //template<class T> static inline void bindTexture(const char* name, const DevMem2D_<T>& img)
+    //{            
+    //    //!!!! const_cast is disabled!
+    //    //!!!! Please use constructor of 'class texture'  instead.
+    //
+    //    //textureReference* tex; 
+    //    //cudaSafeCall( cudaGetTextureReference((const textureReference**)&tex, name) ); 
+    //    //tex->normalized = normalized;
+    //    //tex->filterMode = filterMode;
+    //    //tex->addressMode[0] = addrMode;
+    //    //tex->addressMode[1] = addrMode;
+    //    
+    //    const textureReference* tex; 
+    //    cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
+    //
+    //    cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    //    cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+    //}
+
+    //static inline void unbindTexture(const char *name)
+    //{
+    //    const textureReference* tex; 
+    //    cudaSafeCall( cudaGetTextureReference(&tex, name) ); 
+    //    cudaSafeCall( cudaUnbindTexture(tex) );
+    //}
+
+    
+
+    //class TextureBinder
+    //{
+    //public:
+    //    TextureBinder() : tex_(0) {}
+    //    template <typename T> TextureBinder(const textureReference* tex, const DevMem2D_<T>& img) : tex_(0)
+    //    {
+    //        bind(tex, img);
+    //    }
+    //    template <typename T> TextureBinder(const char* tex_name, const DevMem2D_<T>& img) : tex_(0)
+    //    {
+    //        bind(tex_name, img);
+    //    }
+    //    ~TextureBinder() { unbind(); }
+    //
+    //    template <typename T> void bind(const textureReference* tex, const DevMem2D_<T>& img)
+    //    {
+    //        unbind();
+    //
+    //        cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
+    //        cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
+    //
+    //        tex_ = tex;
+    //    }
+    //    template <typename T> void bind(const char* tex_name, const DevMem2D_<T>& img)
+    //    {
+    //        const textureReference* tex; 
+    //        cudaSafeCall( cudaGetTextureReference(&tex, tex_name) ); 
+    //        bind(tex, img);
+    //    }
+    //
+    //    void unbind()
+    //    {
+    //        if (tex_)
+    //        {
+    //            cudaUnbindTexture(tex_);
+    //            tex_ = 0;
+    //        }
+    //    }
+    //
+    //private:
+    //    const textureReference* tex_;
+    //};
+
+    class NppStreamHandler
+    {
+    public:
+        inline explicit NppStreamHandler(cudaStream_t newStream = 0)
+        {
+            oldStream = nppGetStream();
+            nppSetStream(newStream);
+        }
+
+        inline ~NppStreamHandler()
+        {
+            nppSetStream(oldStream);
+        }
+
+    private:
+        cudaStream_t oldStream;
+    };
+
+    class NppStStreamHandler
+    {
+    public:
+        inline explicit NppStStreamHandler(cudaStream_t newStream = 0)
+        {
+            oldStream = nppStSetActiveCUDAstream(newStream);
+        }
+
+        inline ~NppStStreamHandler()
+        {
+            nppStSetActiveCUDAstream(oldStream);
+        }
+
+    private:
+        cudaStream_t oldStream;
+    };
+}}
 
 #endif /* __OPENCV_internal_shared_HPP__ */

modules/gpu/src/cuda/match_template.cu

@@ -43,10 +43,9 @@
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc {
+namespace match_template {
 
 __device__ __forceinline__ float sum(float v) { return v; }
 __device__ __forceinline__ float sum(float2 v) { return v.x + v.y; }
@@ -266,9 +265,9 @@ void matchTemplatePrepared_SQDIFF_8U(int w, int h, const DevMem2D_<unsigned long
 
 __device__ float normAcc(float num, float denum)
 {
-    if (fabs(num) < denum)
+    if (::fabs(num) < denum)
         return num / denum;
-    if (fabs(num) < denum * 1.125f)
+    if (::fabs(num) < denum * 1.125f)
         return num > 0 ? 1 : -1;
     return 0;
 }
@@ -276,9 +275,9 @@ __device__ float normAcc(float num, float denum)
 
 __device__ float normAcc_SQDIFF(float num, float denum)
 {
-    if (fabs(num) < denum)
+    if (::fabs(num) < denum)
         return num / denum;
-    if (fabs(num) < denum * 1.125f)
+    if (::fabs(num) < denum * 1.125f)
         return num > 0 ? 1 : -1;
     return 1;
 }
@@ -906,4 +905,7 @@ void extractFirstChannel_32F(const DevMem2Db image, DevMem2Df result, int cn, cu
     if (stream == 0)
         cudaSafeCall( cudaDeviceSynchronize() );
 }
-}}}
+
+} //namespace match_template
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/mathfunc.cu

@@ -42,178 +42,174 @@
 
 #include "internal_shared.hpp"
 
-using namespace cv::gpu;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-#ifndef CV_PI
-#define CV_PI   3.1415926535897932384626433832795f
-#endif
+namespace mathfunc {
 
 //////////////////////////////////////////////////////////////////////////////////////
 // Cart <-> Polar
 
-namespace cv { namespace gpu { namespace mathfunc
+struct Nothing
 {
-    struct Nothing
+    static __device__ __forceinline__ void calc(int, int, float, float, float*, size_t, float)
     {
-        static __device__ __forceinline__ void calc(int, int, float, float, float*, size_t, float)
-        {
-        }
-    };
-    struct Magnitude
-    {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
-        {
-            dst[y * dst_step + x] = sqrtf(x_data * x_data + y_data * y_data);
-        }
-    };
-    struct MagnitudeSqr
-    {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
-        {
-            dst[y * dst_step + x] = x_data * x_data + y_data * y_data;
-        }
-    };
-    struct Atan2
-    {
-        static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float scale)
-        {
-            float angle = atan2f(y_data, x_data);
-            angle += (angle < 0) * 2.0 * CV_PI;
-            dst[y * dst_step + x] = scale * angle;
-        }
-    };
-    template <typename Mag, typename Angle>
-    __global__ void cartToPolar(const float* xptr, size_t x_step, const float* yptr, size_t y_step, 
-                                float* mag, size_t mag_step, float* angle, size_t angle_step, float scale, int width, int height)
-    {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < width && y < height)
-        {
-            float x_data = xptr[y * x_step + x];
-            float y_data = yptr[y * y_step + x];
-
-            Mag::calc(x, y, x_data, y_data, mag, mag_step, scale);
-            Angle::calc(x, y, x_data, y_data, angle, angle_step, scale);
-        }
     }
-
-    struct NonEmptyMag
+};
+struct Magnitude
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
     {
-        static __device__ __forceinline__ float get(const float* mag, size_t mag_step, int x, int y)
-        {
-            return mag[y * mag_step + x];
-        }
-    };
-    struct EmptyMag
-    {
-        static __device__ __forceinline__ float get(const float*, size_t, int, int)
-        {
-            return 1.0f;
-        }
-    };
-    template <typename Mag>
-    __global__ void polarToCart(const float* mag, size_t mag_step, const float* angle, size_t angle_step, float scale,
-        float* xptr, size_t x_step, float* yptr, size_t y_step, int width, int height)
-    {
-		const int x = blockDim.x * blockIdx.x + threadIdx.x;
-		const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < width && y < height)
-        {
-            float mag_data = Mag::get(mag, mag_step, x, y);
-            float angle_data = angle[y * angle_step + x];
-            float sin_a, cos_a;
-
-            sincosf(scale * angle_data, &sin_a, &cos_a);
-
-            xptr[y * x_step + x] = mag_data * cos_a;
-            yptr[y * y_step + x] = mag_data * sin_a;
-        }
+        dst[y * dst_step + x] = ::sqrtf(x_data * x_data + y_data * y_data);
     }
-
-    template <typename Mag, typename Angle>
-    void cartToPolar_caller(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream)
+};
+struct MagnitudeSqr
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float)
     {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-
-        grid.x = divUp(x.cols, threads.x);
-        grid.y = divUp(x.rows, threads.y);
-        
-        const float scale = angleInDegrees ? (float)(180.0f / CV_PI) : 1.f;
-
-        cartToPolar<Mag, Angle><<<grid, threads, 0, stream>>>(
-            x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), 
-            mag.data, mag.step/mag.elemSize(), angle.data, angle.step/angle.elemSize(), scale, x.cols, x.rows);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        dst[y * dst_step + x] = x_data * x_data + y_data * y_data;
     }
-
-    void cartToPolar_gpu(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, bool magSqr, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream)
+};
+struct Atan2
+{
+    static __device__ __forceinline__ void calc(int x, int y, float x_data, float y_data, float* dst, size_t dst_step, float scale)
+    {
+        float angle = ::atan2f(y_data, x_data);
+        angle += (angle < 0) * 2.0 * CV_PI;
+        dst[y * dst_step + x] = scale * angle;
+    }
+};
+template <typename Mag, typename Angle>
+__global__ void cartToPolar(const float* xptr, size_t x_step, const float* yptr, size_t y_step, 
+                            float* mag, size_t mag_step, float* angle, size_t angle_step, float scale, int width, int height)
+{
+	const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < width && y < height)
+    {
+        float x_data = xptr[y * x_step + x];
+        float y_data = yptr[y * y_step + x];
+
+        Mag::calc(x, y, x_data, y_data, mag, mag_step, scale);
+        Angle::calc(x, y, x_data, y_data, angle, angle_step, scale);
+    }
+}
+
+struct NonEmptyMag
+{
+    static __device__ __forceinline__ float get(const float* mag, size_t mag_step, int x, int y)
+    {
+        return mag[y * mag_step + x];
+    }
+};
+struct EmptyMag
+{
+    static __device__ __forceinline__ float get(const float*, size_t, int, int)
+    {
+        return 1.0f;
+    }
+};
+template <typename Mag>
+__global__ void polarToCart(const float* mag, size_t mag_step, const float* angle, size_t angle_step, float scale,
+    float* xptr, size_t x_step, float* yptr, size_t y_step, int width, int height)
+{
+	const int x = blockDim.x * blockIdx.x + threadIdx.x;
+	const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < width && y < height)
+    {
+        float mag_data = Mag::get(mag, mag_step, x, y);
+        float angle_data = angle[y * angle_step + x];
+        float sin_a, cos_a;
+
+        ::sincosf(scale * angle_data, &sin_a, &cos_a);
+
+        xptr[y * x_step + x] = mag_data * cos_a;
+        yptr[y * y_step + x] = mag_data * sin_a;
+    }
+}
+
+template <typename Mag, typename Angle>
+void cartToPolar_caller(DevMem2Df x, DevMem2Df y, DevMem2Df mag, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+
+    grid.x = divUp(x.cols, threads.x);
+    grid.y = divUp(x.rows, threads.y);
+    
+    const float scale = angleInDegrees ? (float)(180.0f / CV_PI) : 1.f;
+
+    cartToPolar<Mag, Angle><<<grid, threads, 0, stream>>>(
+        x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), 
+        mag.data, mag.step/mag.elemSize(), angle.data, angle.step/angle.elemSize(), scale, x.cols, x.rows);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+void cartToPolar_gpu(DevMem2Df x, DevMem2Df y, DevMem2Df mag, bool magSqr, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream)
+{
+    typedef void (*caller_t)(DevMem2Df x, DevMem2Df y, DevMem2Df mag, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream);
+    static const caller_t callers[2][2][2] = 
     {
-        typedef void (*caller_t)(const DevMem2Df& x, const DevMem2Df& y, const DevMem2Df& mag, const DevMem2Df& angle, bool angleInDegrees, cudaStream_t stream);
-        static const caller_t callers[2][2][2] = 
         {
             {
-                {
-                    cartToPolar_caller<Magnitude, Atan2>,
-                    cartToPolar_caller<Magnitude, Nothing>
-                },
-                {
-                    cartToPolar_caller<MagnitudeSqr, Atan2>,
-                    cartToPolar_caller<MagnitudeSqr, Nothing>,
-                }
+                cartToPolar_caller<Magnitude, Atan2>,
+                cartToPolar_caller<Magnitude, Nothing>
             },
             {
-                {
-                    cartToPolar_caller<Nothing, Atan2>,
-                    cartToPolar_caller<Nothing, Nothing>
-                },
-                {
-                    cartToPolar_caller<Nothing, Atan2>,
-                    cartToPolar_caller<Nothing, Nothing>,
-                }
+                cartToPolar_caller<MagnitudeSqr, Atan2>,
+                cartToPolar_caller<MagnitudeSqr, Nothing>,
             }
-        };
-
-        callers[mag.data == 0][magSqr][angle.data == 0](x, y, mag, angle, angleInDegrees, stream);
-    }
-
-    template <typename Mag>
-    void polarToCart_caller(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-
-        grid.x = divUp(mag.cols, threads.x);
-        grid.y = divUp(mag.rows, threads.y);
-        
-        const float scale = angleInDegrees ? (float)(CV_PI / 180.0f) : 1.0f;
-
-        polarToCart<Mag><<<grid, threads, 0, stream>>>(mag.data, mag.step/mag.elemSize(), 
-            angle.data, angle.step/angle.elemSize(), scale, x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), mag.cols, mag.rows);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-    void polarToCart_gpu(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream)
-    {
-        typedef void (*caller_t)(const DevMem2Df& mag, const DevMem2Df& angle, const DevMem2Df& x, const DevMem2Df& y, bool angleInDegrees, cudaStream_t stream);
-        static const caller_t callers[2] = 
+        },
         {
-            polarToCart_caller<NonEmptyMag>,
-            polarToCart_caller<EmptyMag>
-        };
+            {
+                cartToPolar_caller<Nothing, Atan2>,
+                cartToPolar_caller<Nothing, Nothing>
+            },
+            {
+                cartToPolar_caller<Nothing, Atan2>,
+                cartToPolar_caller<Nothing, Nothing>,
+            }
+        }
+    };
 
-        callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
-    }
-}}}
+    callers[mag.data == 0][magSqr][angle.data == 0](x, y, mag, angle, angleInDegrees, stream);
+}
 
+template <typename Mag>
+void polarToCart_caller(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
+    grid.x = divUp(mag.cols, threads.x);
+    grid.y = divUp(mag.rows, threads.y);
+    
+    const float scale = angleInDegrees ? (float)(CV_PI / 180.0f) : 1.0f;
 
+    polarToCart<Mag><<<grid, threads, 0, stream>>>(mag.data, mag.step/mag.elemSize(), 
+        angle.data, angle.step/angle.elemSize(), scale, x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(), mag.cols, mag.rows);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+void polarToCart_gpu(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream)
+{
+    typedef void (*caller_t)(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream);
+    static const caller_t callers[2] = 
+    {
+        polarToCart_caller<NonEmptyMag>,
+        polarToCart_caller<EmptyMag>
+    };
+
+    callers[mag.data == 0](mag, angle, x, y, angleInDegrees, stream);
+}
+
+} // namespace mathfunc
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/matrix_operations.cu

@@ -45,302 +45,304 @@
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
-namespace cv { namespace gpu { namespace device {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T> struct shift_and_sizeof;
-    template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
-    template <> struct shift_and_sizeof<unsigned char> { enum { shift = 0 }; };
-    template <> struct shift_and_sizeof<short> { enum { shift = 1 }; };
-    template <> struct shift_and_sizeof<unsigned short> { enum { shift = 1 }; };
-    template <> struct shift_and_sizeof<int> { enum { shift = 2 }; };
-    template <> struct shift_and_sizeof<float> { enum { shift = 2 }; };
-    template <> struct shift_and_sizeof<double> { enum { shift = 3 }; };
+template <typename T> struct shift_and_sizeof;
+template <> struct shift_and_sizeof<signed char> { enum { shift = 0 }; };
+template <> struct shift_and_sizeof<unsigned char> { enum { shift = 0 }; };
+template <> struct shift_and_sizeof<short> { enum { shift = 1 }; };
+template <> struct shift_and_sizeof<unsigned short> { enum { shift = 1 }; };
+template <> struct shift_and_sizeof<int> { enum { shift = 2 }; };
+template <> struct shift_and_sizeof<float> { enum { shift = 2 }; };
+template <> struct shift_and_sizeof<double> { enum { shift = 3 }; };
 
 ///////////////////////////////////////////////////////////////////////////
 ////////////////////////////////// CopyTo /////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    template<typename T>
-    __global__ void copy_to_with_mask(const T* mat_src, T* mat_dst, const uchar* mask, int cols, int rows, size_t step_mat, size_t step_mask, int channels)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+template<typename T>
+__global__ void copy_to_with_mask(const T* mat_src, T* mat_dst, const uchar* mask, int cols, int rows, size_t step_mat, size_t step_mask, int channels)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if ((x < cols * channels ) && (y < rows))
-            if (mask[y * step_mask + x / channels] != 0)
-            {
-                size_t idx = y * ( step_mat >> shift_and_sizeof<T>::shift ) + x;
-                mat_dst[idx] = mat_src[idx];
-            }
-    }
+    if ((x < cols * channels ) && (y < rows))
+        if (mask[y * step_mask + x / channels] != 0)
+        {
+            size_t idx = y * ( step_mat >> shift_and_sizeof<T>::shift ) + x;
+            mat_dst[idx] = mat_src[idx];
+        }
+}
+
+template<typename T>
+void copy_to_with_mask_run(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+{
+    dim3 threadsPerBlock(16,16, 1);
+    dim3 numBlocks ( divUp(mat_src.cols * channels , threadsPerBlock.x) , divUp(mat_src.rows , threadsPerBlock.y), 1);
+
+    copy_to_with_mask<T><<<numBlocks,threadsPerBlock, 0, stream>>>
+            ((T*)mat_src.data, (T*)mat_dst.data, (unsigned char*)mask.data, mat_src.cols, mat_src.rows, mat_src.step, mask.step, channels);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
+
+void copy_to_with_mask(const DevMem2Db& mat_src, DevMem2Db mat_dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+{
     typedef void (*CopyToFunc)(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream);
 
-    template<typename T>
-    void copy_to_with_mask_run(const DevMem2Db& mat_src, const DevMem2Db& mat_dst, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
+    static CopyToFunc tab[8] =
     {
-        dim3 threadsPerBlock(16,16, 1);
-        dim3 numBlocks ( divUp(mat_src.cols * channels , threadsPerBlock.x) , divUp(mat_src.rows , threadsPerBlock.y), 1);
+        copy_to_with_mask_run<unsigned char>,
+        copy_to_with_mask_run<signed char>,
+        copy_to_with_mask_run<unsigned short>,
+        copy_to_with_mask_run<short>,
+        copy_to_with_mask_run<int>,
+        copy_to_with_mask_run<float>,
+        copy_to_with_mask_run<double>,
+        0
+    };
 
-        copy_to_with_mask<T><<<numBlocks,threadsPerBlock, 0, stream>>>
-                ((T*)mat_src.data, (T*)mat_dst.data, (unsigned char*)mask.data, mat_src.cols, mat_src.rows, mat_src.step, mask.step, channels);
-        cudaSafeCall( cudaGetLastError() );
+    CopyToFunc func = tab[depth];
 
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
+    if (func == 0) cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
 
-    void copy_to_with_mask(const DevMem2Db& mat_src, DevMem2Db mat_dst, int depth, const DevMem2Db& mask, int channels, const cudaStream_t & stream)
-    {
-        static CopyToFunc tab[8] =
-        {
-            copy_to_with_mask_run<unsigned char>,
-            copy_to_with_mask_run<signed char>,
-            copy_to_with_mask_run<unsigned short>,
-            copy_to_with_mask_run<short>,
-            copy_to_with_mask_run<int>,
-            copy_to_with_mask_run<float>,
-            copy_to_with_mask_run<double>,
-            0
-        };
-
-        CopyToFunc func = tab[depth];
-
-        if (func == 0) cv::gpu::error("Unsupported copyTo operation", __FILE__, __LINE__);
-
-        func(mat_src, mat_dst, mask, channels, stream);
-    }
+    func(mat_src, mat_dst, mask, channels, stream);
+}
 
 ///////////////////////////////////////////////////////////////////////////
 ////////////////////////////////// SetTo //////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    __constant__ uchar scalar_8u[4];
-    __constant__ schar scalar_8s[4];
-    __constant__ ushort scalar_16u[4];
-    __constant__ short scalar_16s[4];
-    __constant__ int scalar_32s[4];
-    __constant__ float scalar_32f[4]; 
-    __constant__ double scalar_64f[4];
+__constant__ uchar scalar_8u[4];
+__constant__ schar scalar_8s[4];
+__constant__ ushort scalar_16u[4];
+__constant__ short scalar_16s[4];
+__constant__ int scalar_32s[4];
+__constant__ float scalar_32f[4]; 
+__constant__ double scalar_64f[4];
 
-    template <typename T> __device__ __forceinline__ T readScalar(int i);
-    template <> __device__ __forceinline__ uchar readScalar<uchar>(int i) {return scalar_8u[i];}
-    template <> __device__ __forceinline__ schar readScalar<schar>(int i) {return scalar_8s[i];}
-    template <> __device__ __forceinline__ ushort readScalar<ushort>(int i) {return scalar_16u[i];}
-    template <> __device__ __forceinline__ short readScalar<short>(int i) {return scalar_16s[i];}
-    template <> __device__ __forceinline__ int readScalar<int>(int i) {return scalar_32s[i];}
-    template <> __device__ __forceinline__ float readScalar<float>(int i) {return scalar_32f[i];}
-    template <> __device__ __forceinline__ double readScalar<double>(int i) {return scalar_64f[i];}
+template <typename T> __device__ __forceinline__ T readScalar(int i);
+template <> __device__ __forceinline__ uchar readScalar<uchar>(int i) {return scalar_8u[i];}
+template <> __device__ __forceinline__ schar readScalar<schar>(int i) {return scalar_8s[i];}
+template <> __device__ __forceinline__ ushort readScalar<ushort>(int i) {return scalar_16u[i];}
+template <> __device__ __forceinline__ short readScalar<short>(int i) {return scalar_16s[i];}
+template <> __device__ __forceinline__ int readScalar<int>(int i) {return scalar_32s[i];}
+template <> __device__ __forceinline__ float readScalar<float>(int i) {return scalar_32f[i];}
+template <> __device__ __forceinline__ double readScalar<double>(int i) {return scalar_64f[i];}
 
-    void writeScalar(const uchar* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_8u, vals, sizeof(uchar) * 4) );
-    }
-    void writeScalar(const schar* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_8s, vals, sizeof(schar) * 4) );
-    }
-    void writeScalar(const ushort* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_16u, vals, sizeof(ushort) * 4) );
-    }
-    void writeScalar(const short* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_16s, vals, sizeof(short) * 4) );
-    }
-    void writeScalar(const int* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_32s, vals, sizeof(int) * 4) );
-    }
-    void writeScalar(const float* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_32f, vals, sizeof(float) * 4) );
-    }
-    void writeScalar(const double* vals)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(scalar_64f, vals, sizeof(double) * 4) );
-    }
+void writeScalar(const uchar* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_8u, vals, sizeof(uchar) * 4) );
+}
+void writeScalar(const schar* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_8s, vals, sizeof(schar) * 4) );
+}
+void writeScalar(const ushort* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_16u, vals, sizeof(ushort) * 4) );
+}
+void writeScalar(const short* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_16s, vals, sizeof(short) * 4) );
+}
+void writeScalar(const int* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_32s, vals, sizeof(int) * 4) );
+}
+void writeScalar(const float* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_32f, vals, sizeof(float) * 4) );
+}
+void writeScalar(const double* vals)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(scalar_64f, vals, sizeof(double) * 4) );
+}
 
-    template<typename T>
-    __global__ void set_to_without_mask(T* mat, int cols, int rows, size_t step, int channels)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+template<typename T>
+__global__ void set_to_without_mask(T* mat, int cols, int rows, size_t step, int channels)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if ((x < cols * channels ) && (y < rows))
+    if ((x < cols * channels ) && (y < rows))
+    {
+        size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
+        mat[idx] = readScalar<T>(x % channels);
+    }
+}
+
+template<typename T>
+__global__ void set_to_with_mask(T* mat, const uchar* mask, int cols, int rows, size_t step, int channels, size_t step_mask)
+{
+    size_t x = blockIdx.x * blockDim.x + threadIdx.x;
+    size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if ((x < cols * channels ) && (y < rows))
+        if (mask[y * step_mask + x / channels] != 0)
         {
             size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
             mat[idx] = readScalar<T>(x % channels);
         }
-    }
+}
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream)
+{
+    writeScalar(scalar);
 
-    template<typename T>
-    __global__ void set_to_with_mask(T* mat, const uchar* mask, int cols, int rows, size_t step, int channels, size_t step_mask)
-    {
-        size_t x = blockIdx.x * blockDim.x + threadIdx.x;
-        size_t y = blockIdx.y * blockDim.y + threadIdx.y;
+    dim3 threadsPerBlock(32, 8, 1);
+    dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
 
-        if ((x < cols * channels ) && (y < rows))
-            if (mask[y * step_mask + x / channels] != 0)
-            {
-                size_t idx = y * ( step >> shift_and_sizeof<T>::shift ) + x;
-                mat[idx] = readScalar<T>(x % channels);
-            }
-    }
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream)
-    {
-        writeScalar(scalar);
+    set_to_with_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, (uchar*)mask.data, mat.cols, mat.rows, mat.step, channels, mask.step);
+    cudaSafeCall( cudaGetLastError() );
 
-        dim3 threadsPerBlock(32, 8, 1);
-        dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
 
-        set_to_with_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, (uchar*)mask.data, mat.cols, mat.rows, mat.step, channels, mask.step);
-        cudaSafeCall( cudaGetLastError() );
+template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
 
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
+template <typename T>
+void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream)
+{
+    writeScalar(scalar);
 
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, const DevMem2Db& mask, int channels, cudaStream_t stream);
+    dim3 threadsPerBlock(32, 8, 1);
+    dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
 
-    template <typename T>
-    void set_to_gpu(const DevMem2Db& mat, const T* scalar, int channels, cudaStream_t stream)
-    {
-        writeScalar(scalar);
+    set_to_without_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, mat.cols, mat.rows, mat.step, channels);
+    cudaSafeCall( cudaGetLastError() );
 
-        dim3 threadsPerBlock(32, 8, 1);
-        dim3 numBlocks (mat.cols * channels / threadsPerBlock.x + 1, mat.rows / threadsPerBlock.y + 1, 1);
+    if (stream == 0)
+        cudaSafeCall ( cudaDeviceSynchronize() );
+}
 
-        set_to_without_mask<T><<<numBlocks, threadsPerBlock, 0, stream>>>((T*)mat.data, mat.cols, mat.rows, mat.step, channels);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall ( cudaDeviceSynchronize() );
-    }
-
-    template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, int channels, cudaStream_t stream);
-    template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<uchar >(const DevMem2Db& mat, const uchar* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<schar >(const DevMem2Db& mat, const schar* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<ushort>(const DevMem2Db& mat, const ushort* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<short >(const DevMem2Db& mat, const short* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<int   >(const DevMem2Db& mat, const int* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<float >(const DevMem2Db& mat, const float* scalar, int channels, cudaStream_t stream);
+template void set_to_gpu<double>(const DevMem2Db& mat, const double* scalar, int channels, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////////////////
 //////////////////////////////// ConvertTo ////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
-    template <typename T, typename D> struct Convertor : unary_function<T, D>
+template <typename T, typename D> struct Convertor : unary_function<T, D>
+{
+    Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
+
+    __device__ __forceinline__ D operator()(const T& src) const
     {
-        Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
-
-        __device__ __forceinline__ D operator()(const T& src) const
-        {
-            return saturate_cast<D>(alpha * src + beta);
-        }
-
-        const double alpha, beta;
-    };
-
-    namespace detail
-    {
-        template <size_t src_size, size_t dst_size, typename F> struct ConvertTraitsDispatcher : DefaultTransformFunctorTraits<F>
-        {
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 1, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 8 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<1, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 4 };
-        };
-
-        template <typename F> struct ConvertTraitsDispatcher<2, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<2, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 2 };
-        };
-
-        template <typename F> struct ConvertTraitsDispatcher<4, 2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ConvertTraitsDispatcher<4, 4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 2 };
-        };
-
-        template <typename F> struct ConvertTraits : ConvertTraitsDispatcher<sizeof(typename F::argument_type), sizeof(typename F::result_type), F>
-        {
-        };
+        return saturate_cast<D>(alpha * src + beta);
     }
 
-    template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
+    const double alpha, beta;
+};
+
+namespace detail
+{
+    template <size_t src_size, size_t dst_size, typename F> struct ConvertTraitsDispatcher : DefaultTransformFunctorTraits<F>
     {
     };
-        
-    template<typename T, typename D>
-    void cvt_(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, cudaStream_t stream)
+    template <typename F> struct ConvertTraitsDispatcher<1, 1, F> : DefaultTransformFunctorTraits<F>
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
-        cudaSafeCall( cudaSetDoubleForDevice(&beta) );
-        Convertor<T, D> op(alpha, beta);
-        transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, stream);
-    }
-
-    void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, 
-        cudaStream_t stream = 0)
+        enum { smart_shift = 8 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<1, 2, F> : DefaultTransformFunctorTraits<F>
     {
-        typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, 
-            cudaStream_t stream);
+        enum { smart_shift = 4 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<1, 4, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
 
-        static const caller_t tab[8][8] =
-        {
-            {cvt_<uchar, uchar>, cvt_<uchar, schar>, cvt_<uchar, ushort>, cvt_<uchar, short>,
-            cvt_<uchar, int>, cvt_<uchar, float>, cvt_<uchar, double>, 0},
+    template <typename F> struct ConvertTraitsDispatcher<2, 2, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_shift = 4 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<2, 4, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_shift = 2 };
+    };
 
-            {cvt_<schar, uchar>, cvt_<schar, schar>, cvt_<schar, ushort>, cvt_<schar, short>,
-            cvt_<schar, int>, cvt_<schar, float>, cvt_<schar, double>, 0},
+    template <typename F> struct ConvertTraitsDispatcher<4, 2, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <typename F> struct ConvertTraitsDispatcher<4, 4, F> : DefaultTransformFunctorTraits<F>
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 2 };
+    };
 
-            {cvt_<ushort, uchar>, cvt_<ushort, schar>, cvt_<ushort, ushort>, cvt_<ushort, short>,
-            cvt_<ushort, int>, cvt_<ushort, float>, cvt_<ushort, double>, 0},
+    template <typename F> struct ConvertTraits : ConvertTraitsDispatcher<sizeof(typename F::argument_type), sizeof(typename F::result_type), F>
+    {
+    };
+}
 
-            {cvt_<short, uchar>, cvt_<short, schar>, cvt_<short, ushort>, cvt_<short, short>,
-            cvt_<short, int>, cvt_<short, float>, cvt_<short, double>, 0},
+template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
+{
+};
+    
+template<typename T, typename D>
+void cvt_(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, cudaStream_t stream)
+{
+    cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
+    cudaSafeCall( cudaSetDoubleForDevice(&beta) );
+    Convertor<T, D> op(alpha, beta);
+    OPENCV_DEVICE_NAMESPACE_ transform((DevMem2D_<T>)src, (DevMem2D_<D>)dst, op, stream);
+}
 
-            {cvt_<int, uchar>, cvt_<int, schar>, cvt_<int, ushort>,
-            cvt_<int, short>, cvt_<int, int>, cvt_<int, float>, cvt_<int, double>, 0},
+void convert_gpu(const DevMem2Db& src, int sdepth, const DevMem2Db& dst, int ddepth, double alpha, double beta, 
+    cudaStream_t stream = 0)
+{
+    typedef void (*caller_t)(const DevMem2Db& src, const DevMem2Db& dst, double alpha, double beta, 
+        cudaStream_t stream);
 
-            {cvt_<float, uchar>, cvt_<float, schar>, cvt_<float, ushort>,
-            cvt_<float, short>, cvt_<float, int>, cvt_<float, float>, cvt_<float, double>, 0},
+    static const caller_t tab[8][8] =
+    {
+        {cvt_<uchar, uchar>, cvt_<uchar, schar>, cvt_<uchar, ushort>, cvt_<uchar, short>,
+        cvt_<uchar, int>, cvt_<uchar, float>, cvt_<uchar, double>, 0},
 
-            {cvt_<double, uchar>, cvt_<double, schar>, cvt_<double, ushort>,
-            cvt_<double, short>, cvt_<double, int>, cvt_<double, float>, cvt_<double, double>, 0},
+        {cvt_<schar, uchar>, cvt_<schar, schar>, cvt_<schar, ushort>, cvt_<schar, short>,
+        cvt_<schar, int>, cvt_<schar, float>, cvt_<schar, double>, 0},
 
-            {0,0,0,0,0,0,0,0}
-        };
+        {cvt_<ushort, uchar>, cvt_<ushort, schar>, cvt_<ushort, ushort>, cvt_<ushort, short>,
+        cvt_<ushort, int>, cvt_<ushort, float>, cvt_<ushort, double>, 0},
 
-        caller_t func = tab[sdepth][ddepth];
-        if (!func)
-            cv::gpu::error("Unsupported convert operation", __FILE__, __LINE__);
+        {cvt_<short, uchar>, cvt_<short, schar>, cvt_<short, ushort>, cvt_<short, short>,
+        cvt_<short, int>, cvt_<short, float>, cvt_<short, double>, 0},
 
-        func(src, dst, alpha, beta, stream);
-    }
-}}}
+        {cvt_<int, uchar>, cvt_<int, schar>, cvt_<int, ushort>,
+        cvt_<int, short>, cvt_<int, int>, cvt_<int, float>, cvt_<int, double>, 0},
+
+        {cvt_<float, uchar>, cvt_<float, schar>, cvt_<float, ushort>,
+        cvt_<float, short>, cvt_<float, int>, cvt_<float, float>, cvt_<float, double>, 0},
+
+        {cvt_<double, uchar>, cvt_<double, schar>, cvt_<double, ushort>,
+        cvt_<double, short>, cvt_<double, int>, cvt_<double, float>, cvt_<double, double>, 0},
+
+        {0,0,0,0,0,0,0,0}
+    };
+
+    caller_t func = tab[sdepth][ddepth];
+    if (!func)
+        cv::gpu::error("Unsupported convert operation", __FILE__, __LINE__);
+
+    func(src, dst, alpha, beta, stream);
+}
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/matrix_reductions.cu

@@ -40,79 +40,73 @@
 //
 //M*/
 
+#include "internal_shared.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
-#include "internal_shared.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace mathfunc
+namespace matrix_reductions {
+
+// Performs reduction in shared memory
+template <int size, typename T>
+__device__ void sumInSmem(volatile T* data, const uint tid)
 {
+    T sum = data[tid];
 
-    // Performs reduction in shared memory
-    template <int size, typename T>
-    __device__ void sumInSmem(volatile T* data, const uint tid)
+    if (size >= 512) { if (tid < 256) { data[tid] = sum = sum + data[tid + 256]; } __syncthreads(); }
+    if (size >= 256) { if (tid < 128) { data[tid] = sum = sum + data[tid + 128]; } __syncthreads(); }
+    if (size >= 128) { if (tid < 64) { data[tid] = sum = sum + data[tid + 64]; } __syncthreads(); }
+
+    if (tid < 32)
     {
-        T sum = data[tid];
+        if (size >= 64) data[tid] = sum = sum + data[tid + 32];
+        if (size >= 32) data[tid] = sum = sum + data[tid + 16];
+        if (size >= 16) data[tid] = sum = sum + data[tid + 8];
+        if (size >= 8) data[tid] = sum = sum + data[tid + 4];
+        if (size >= 4) data[tid] = sum = sum + data[tid + 2];
+        if (size >= 2) data[tid] = sum = sum + data[tid + 1];
+    }
+}
 
-        if (size >= 512) { if (tid < 256) { data[tid] = sum = sum + data[tid + 256]; } __syncthreads(); }
-        if (size >= 256) { if (tid < 128) { data[tid] = sum = sum + data[tid + 128]; } __syncthreads(); }
-        if (size >= 128) { if (tid < 64) { data[tid] = sum = sum + data[tid + 64]; } __syncthreads(); }
+struct Mask8U
+{
+    explicit Mask8U(PtrStepb mask): mask(mask) {}
 
-        if (tid < 32)
-        {
-            if (size >= 64) data[tid] = sum = sum + data[tid + 32];
-            if (size >= 32) data[tid] = sum = sum + data[tid + 16];
-            if (size >= 16) data[tid] = sum = sum + data[tid + 8];
-            if (size >= 8) data[tid] = sum = sum + data[tid + 4];
-            if (size >= 4) data[tid] = sum = sum + data[tid + 2];
-            if (size >= 2) data[tid] = sum = sum + data[tid + 1];
-        }
+    __device__ __forceinline__ bool operator()(int y, int x) const 
+    { 
+        return mask.ptr(y)[x]; 
     }
 
+    PtrStepb mask;
+};
 
-    struct Mask8U
-    {
-        explicit Mask8U(PtrStepb mask): mask(mask) {}
-
-        __device__ __forceinline__ bool operator()(int y, int x) const 
-        { 
-            return mask.ptr(y)[x]; 
-        }
-
-        PtrStepb mask;
-    };
-
-
-    struct MaskTrue 
+struct MaskTrue 
+{ 
+    __device__ __forceinline__ bool operator()(int y, int x) const 
     { 
-        __device__ __forceinline__ bool operator()(int y, int x) const 
-        { 
-            return true; 
-        } 
-    };
+        return true; 
+    } 
+};
 
-    //////////////////////////////////////////////////////////////////////////////
-    // Min max
+//////////////////////////////////////////////////////////////////////////////
+// Min max
 
-    // To avoid shared bank conflicts we convert each value into value of 
-    // appropriate type (32 bits minimum)
-    template <typename T> struct MinMaxTypeTraits {};
-    template <> struct MinMaxTypeTraits<uchar> { typedef int best_type; };
-    template <> struct MinMaxTypeTraits<char> { typedef int best_type; };
-    template <> struct MinMaxTypeTraits<ushort> { typedef int best_type; };
-    template <> struct MinMaxTypeTraits<short> { typedef int best_type; };
-    template <> struct MinMaxTypeTraits<int> { typedef int best_type; };
-    template <> struct MinMaxTypeTraits<float> { typedef float best_type; };
-    template <> struct MinMaxTypeTraits<double> { typedef double best_type; };
-
-
-    namespace minmax 
-    {
+// To avoid shared bank conflicts we convert each value into value of 
+// appropriate type (32 bits minimum)
+template <typename T> struct MinMaxTypeTraits {};
+template <> struct MinMaxTypeTraits<uchar> { typedef int best_type; };
+template <> struct MinMaxTypeTraits<char> { typedef int best_type; };
+template <> struct MinMaxTypeTraits<ushort> { typedef int best_type; };
+template <> struct MinMaxTypeTraits<short> { typedef int best_type; };
+template <> struct MinMaxTypeTraits<int> { typedef int best_type; };
+template <> struct MinMaxTypeTraits<float> { typedef float best_type; };
+template <> struct MinMaxTypeTraits<double> { typedef double best_type; };
 
+namespace minmax 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -126,8 +120,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -155,8 +149,8 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     __device__ __forceinline__ void merge(uint tid, uint offset, volatile T* minval, volatile T* maxval)
     {
-        minval[tid] = min(minval[tid], minval[tid + offset]);
-        maxval[tid] = max(maxval[tid], maxval[tid + offset]);
+        minval[tid] = ::min(minval[tid], minval[tid + offset]);
+        maxval[tid] = ::max(maxval[tid], maxval[tid + offset]);
     }
 
 
@@ -192,8 +186,8 @@ namespace cv { namespace gpu { namespace mathfunc
 
         T mymin = numeric_limits<T>::max();
         T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : numeric_limits<T>::min();
-        uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
-        uint x_end = min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
+        uint y_end = ::min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
+        uint x_end = ::min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
         for (uint y = y0; y < y_end; y += blockDim.y)
         {
             const T* src_row = (const T*)src.ptr(y);
@@ -202,8 +196,8 @@ namespace cv { namespace gpu { namespace mathfunc
                 T val = src_row[x];
                 if (mask(y, x)) 
                 { 
-                    mymin = min(mymin, val); 
-                    mymax = max(mymax, val); 
+                    mymin = ::min(mymin, val); 
+                    mymax = ::max(mymax, val); 
                 }
             }
         }
@@ -220,7 +214,7 @@ namespace cv { namespace gpu { namespace mathfunc
             maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
         }
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -237,7 +231,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
 		if (is_last)
 		{
-            uint idx = min(tid, gridDim.x * gridDim.y - 1);
+            uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
 
             sminval[tid] = minval[idx];
             smaxval[tid] = maxval[idx];
@@ -332,7 +326,7 @@ namespace cv { namespace gpu { namespace mathfunc
         __shared__ best_type smaxval[nthreads];
         
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-        uint idx = min(tid, size - 1);
+        uint idx = ::min(tid, size - 1);
 
         sminval[tid] = minval[idx];
         smaxval[tid] = maxval[idx];
@@ -410,14 +404,13 @@ namespace cv { namespace gpu { namespace mathfunc
     template void minMaxMultipassCaller<short>(const DevMem2Db, double*, double*, PtrStepb);
     template void minMaxMultipassCaller<int>(const DevMem2Db, double*, double*, PtrStepb);
     template void minMaxMultipassCaller<float>(const DevMem2Db, double*, double*, PtrStepb);
-
-    } // namespace minmax
+} // namespace minmax
 
 ///////////////////////////////////////////////////////////////////////////////
 // minMaxLoc
 
-    namespace minmaxloc {
-
+namespace minmaxloc 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -431,8 +424,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -513,12 +506,11 @@ namespace cv { namespace gpu { namespace mathfunc
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
 
         T mymin = numeric_limits<T>::max();
-        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : 
-                                                     numeric_limits<T>::min(); 
+        T mymax = numeric_limits<T>::is_signed ? -numeric_limits<T>::max() : numeric_limits<T>::min(); 
         uint myminloc = 0;
         uint mymaxloc = 0;
-        uint y_end = min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
-        uint x_end = min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
+        uint y_end = ::min(y0 + (ctheight - 1) * blockDim.y + 1, src.rows);
+        uint x_end = ::min(x0 + (ctwidth - 1) * blockDim.x + 1, src.cols);
 
         for (uint y = y0; y < y_end; y += blockDim.y)
         {
@@ -542,7 +534,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         findMinMaxLocInSmem<nthreads, best_type>(sminval, smaxval, sminloc, smaxloc, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -561,7 +553,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
 		if (is_last)
 		{
-            uint idx = min(tid, gridDim.x * gridDim.y - 1);
+            uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
 
             sminval[tid] = minval[idx];
             smaxval[tid] = maxval[idx];
@@ -685,7 +677,7 @@ namespace cv { namespace gpu { namespace mathfunc
         __shared__ uint smaxloc[nthreads];
 
         uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-        uint idx = min(tid, size - 1);
+        uint idx = ::min(tid, size - 1);
 
         sminval[tid] = minval[idx];
         smaxval[tid] = maxval[idx];
@@ -787,15 +779,13 @@ namespace cv { namespace gpu { namespace mathfunc
     template void minMaxLocMultipassCaller<short>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
     template void minMaxLocMultipassCaller<int>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
     template void minMaxLocMultipassCaller<float>(const DevMem2Db, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-    } // namespace minmaxloc
+} // namespace minmaxloc
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////
 // countNonZero
 
-    namespace countnonzero 
-    {
-
+namespace countnonzero 
+{
     __constant__ int ctwidth;
     __constant__ int ctheight;
 
@@ -805,8 +795,8 @@ namespace cv { namespace gpu { namespace mathfunc
     {
         threads = dim3(32, 8);
         grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -850,7 +840,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         sumInSmem<nthreads, uint>(scount, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
 		__shared__ bool is_last;
 
 		if (tid == 0)
@@ -957,15 +947,14 @@ namespace cv { namespace gpu { namespace mathfunc
     template int countNonZeroMultipassCaller<int>(const DevMem2Db, PtrStepb);
     template int countNonZeroMultipassCaller<float>(const DevMem2Db, PtrStepb);
 
-    } // namespace countnonzero
+} // namespace countnonzero
 
 
-    //////////////////////////////////////////////////////////////////////////
-    // Sum
-
-    namespace sums 
-    {
+//////////////////////////////////////////////////////////////////////////
+// Sum
 
+namespace sum
+{
     template <typename T> struct SumType {};
     template <> struct SumType<uchar> { typedef uint R; };
     template <> struct SumType<char> { typedef int R; };
@@ -979,7 +968,7 @@ namespace cv { namespace gpu { namespace mathfunc
     struct IdentityOp { static __device__ __forceinline__ R call(R x) { return x; } };
 
     template <typename R> 
-    struct AbsOp { static __device__ __forceinline__ R call(R x) { return abs(x); } };
+    struct AbsOp { static __device__ __forceinline__ R call(R x) { return ::abs(x); } };
 
     template <>
     struct AbsOp<uint> { static __device__ __forceinline__ uint call(uint x) { return x; } };
@@ -999,8 +988,8 @@ namespace cv { namespace gpu { namespace mathfunc
         threads = dim3(threads_x, threads_y);
         grid = dim3(divUp(cols, threads.x * threads.y), 
                     divUp(rows, threads.y * threads.x));
-        grid.x = min(grid.x, threads.x);
-        grid.y = min(grid.y, threads.y);
+        grid.x = std::min(grid.x, threads.x);
+        grid.y = std::min(grid.y, threads.y);
     }
 
 
@@ -1044,7 +1033,7 @@ namespace cv { namespace gpu { namespace mathfunc
 
         sumInSmem<nthreads, R>(smem, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1125,7 +1114,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem, tid);
         sumInSmem<nthreads, R>(smem + nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1232,7 +1221,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem + nthreads, tid);
         sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1349,7 +1338,7 @@ namespace cv { namespace gpu { namespace mathfunc
         sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
         sumInSmem<nthreads, R>(smem + 3 * nthreads, tid);
 
-#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
+#if __CUDA_ARCH__ >= 110
         __shared__ bool is_last;
 
         if (tid == 0)
@@ -1437,13 +1426,9 @@ namespace cv { namespace gpu { namespace mathfunc
         }
     }
 
-    } // namespace sum
-
-
     template <typename T>
     void sumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1515,7 +1500,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1565,7 +1549,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void absSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1637,7 +1620,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void absSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1687,7 +1669,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sqrSumMultipassCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1759,7 +1740,6 @@ namespace cv { namespace gpu { namespace mathfunc
     template <typename T>
     void sqrSumCaller(const DevMem2Db src, PtrStepb buf, double* sum, int cn)
     {
-        using namespace sums;
         typedef typename SumType<T>::R R;
 
         dim3 threads, grid;
@@ -1804,301 +1784,305 @@ namespace cv { namespace gpu { namespace mathfunc
     template void sqrSumCaller<short>(const DevMem2Db, PtrStepb, double*, int);
     template void sqrSumCaller<int>(const DevMem2Db, PtrStepb, double*, int);
     template void sqrSumCaller<float>(const DevMem2Db, PtrStepb, double*, int);
+} // namespace sum
 
-    //////////////////////////////////////////////////////////////////////////////
-    // reduce
+//////////////////////////////////////////////////////////////////////////////
+// reduce
 
-    template <typename S> struct SumReductor
+template <typename S> struct SumReductor
+{
+    __device__ __forceinline__ S startValue() const
     {
-        __device__ __forceinline__ S startValue() const
-        {
-            return 0;
-        }
-
-        __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
-        {
-            return a + b;
-        }
-
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
-
-    template <typename S> struct AvgReductor
-    {
-        __device__ __forceinline__ S startValue() const
-        {
-            return 0;
-        }
-
-        __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
-        {
-            return a + b;
-        }
-
-        __device__ __forceinline__ double result(S r, double sz) const
-        {
-            return r / sz;
-        }
-    };
-
-    template <typename S> struct MinReductor
-    {
-        __device__ __forceinline__ S startValue() const
-        {
-            return numeric_limits<S>::max();
-        }
-
-        template <typename T> __device__ __forceinline__ T operator ()(volatile T a, volatile T b) const
-        {
-            return saturate_cast<T>(::min(a, b));
-        }
-        __device__ __forceinline__ float operator ()(volatile float a, volatile float b) const
-        {
-            return ::fmin(a, b);
-        }
-
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
-
-    template <typename S> struct MaxReductor
-    {
-        __device__ __forceinline__ S startValue() const
-        {
-            return numeric_limits<S>::min();
-        }
-
-        template <typename T> __device__ __forceinline__ int operator ()(volatile T a, volatile T b) const
-        {
-            return ::max(a, b);
-        }
-        __device__ __forceinline__ float operator ()(volatile float a, volatile float b) const
-        {
-            return ::fmax(a, b);
-        }
-
-        __device__ __forceinline__ S result(S r, double) const
-        {
-            return r;
-        }
-    };
-
-    template <class Op, typename T, typename S, typename D> __global__ void reduceRows(const DevMem2D_<T> src, D* dst, const Op op)
-    {
-        __shared__ S smem[16 * 16];
-
-        const int x = blockIdx.x * 16 + threadIdx.x;
-
-        S myVal = op.startValue();
-
-        if (x < src.cols)
-        {
-            for (int y = threadIdx.y; y < src.rows; y += 16)
-                myVal = op(myVal, src.ptr(y)[x]);
-        }        
-
-        smem[threadIdx.x * 16 + threadIdx.y] = myVal;
-        __syncthreads();
-
-        if (threadIdx.x < 8)
-        {
-            volatile S* srow = smem + threadIdx.y * 16;
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 8]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 4]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 2]);
-            srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 1]);
-        }
-        __syncthreads();
-
-        if (threadIdx.y == 0 && x < src.cols)
-            dst[x] = saturate_cast<D>(op.result(smem[threadIdx.x * 16], src.rows));
+        return 0;
     }
 
-    template <template <typename> class Op, typename T, typename S, typename D> void reduceRows_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+    __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
     {
-        const dim3 block(16, 16);
-        const dim3 grid(divUp(src.cols, block.x));
-
-        Op<S> op;
-        reduceRows<Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-
+        return a + b;
     }
 
-    template <typename T, typename S, typename D> void reduceRows_gpu(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+    __device__ __forceinline__ S result(S r, double) const
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+        return r;
+    }
+};
 
-        static const caller_t callers[] = 
-        {
-            reduceRows_caller<SumReductor, T, S, D>, 
-            reduceRows_caller<AvgReductor, T, S, D>, 
-            reduceRows_caller<MaxReductor, T, S, D>, 
-            reduceRows_caller<MinReductor, T, S, D>
-        };
-
-        callers[reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+template <typename S> struct AvgReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return 0;
     }
 
-    template void reduceRows_gpu<uchar, int, uchar>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<uchar, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<uchar, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
-
-    template void reduceRows_gpu<ushort, int, ushort>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<ushort, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<ushort, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
-
-    template void reduceRows_gpu<short, int, short>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<short, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<short, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
-
-    template void reduceRows_gpu<int, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceRows_gpu<int, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-
-    template void reduceRows_gpu<float, float, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-
-
-
-    template <int cn, class Op, typename T, typename S, typename D> __global__ void reduceCols(const DevMem2D_<T> src, D* dst, const Op op)
+    __device__ __forceinline__ S operator ()(volatile S a, volatile S b) const
     {
-        __shared__ S smem[256 * cn];
+        return a + b;
+    }
 
-        const int y = blockIdx.x;
+    __device__ __forceinline__ double result(S r, double sz) const
+    {
+        return r / sz;
+    }
+};
 
-        const T* src_row = src.ptr(y);
+template <typename S> struct MinReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return numeric_limits<S>::max();
+    }
 
-        S myVal[cn];
+    template <typename T> __device__ __forceinline__ T operator ()(volatile T a, volatile T b) const
+    {
+        return saturate_cast<T>(::min(a, b));
+    }
+    __device__ __forceinline__ float operator ()(volatile float a, volatile float b) const
+    {
+        return ::fmin(a, b);
+    }
 
-        #pragma unroll
-        for (int c = 0; c < cn; ++c)
-            myVal[c] = op.startValue();
+    __device__ __forceinline__ S result(S r, double) const
+    {
+        return r;
+    }
+};
+
+template <typename S> struct MaxReductor
+{
+    __device__ __forceinline__ S startValue() const
+    {
+        return numeric_limits<S>::min();
+    }
+
+    template <typename T> __device__ __forceinline__ int operator ()(volatile T a, volatile T b) const
+    {
+        return ::max(a, b);
+    }
+    __device__ __forceinline__ float operator ()(volatile float a, volatile float b) const
+    {
+        return ::fmax(a, b);
+    }
+
+    __device__ __forceinline__ S result(S r, double) const
+    {
+        return r;
+    }
+};
+
+template <class Op, typename T, typename S, typename D> __global__ void reduceRows(const DevMem2D_<T> src, D* dst, const Op op)
+{
+    __shared__ S smem[16 * 16];
+
+    const int x = blockIdx.x * 16 + threadIdx.x;
+
+    S myVal = op.startValue();
+
+    if (x < src.cols)
+    {
+        for (int y = threadIdx.y; y < src.rows; y += 16)
+            myVal = op(myVal, src.ptr(y)[x]);
+    }        
+
+    smem[threadIdx.x * 16 + threadIdx.y] = myVal;
+    __syncthreads();
+
+    if (threadIdx.x < 8)
+    {
+        volatile S* srow = smem + threadIdx.y * 16;
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 8]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 4]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 2]);
+        srow[threadIdx.x] = op(srow[threadIdx.x], srow[threadIdx.x + 1]);
+    }
+    __syncthreads();
+
+    if (threadIdx.y == 0 && x < src.cols)
+        dst[x] = saturate_cast<D>(op.result(smem[threadIdx.x * 16], src.rows));
+}
+
+template <template <typename> class Op, typename T, typename S, typename D> void reduceRows_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+{
+    const dim3 block(16, 16);
+    const dim3 grid(divUp(src.cols, block.x));
+
+    Op<S> op;
+    reduceRows<Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+}
+
+template <typename T, typename S, typename D> void reduceRows_gpu(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
+    {
+        reduceRows_caller<SumReductor, T, S, D>, 
+        reduceRows_caller<AvgReductor, T, S, D>, 
+        reduceRows_caller<MaxReductor, T, S, D>, 
+        reduceRows_caller<MinReductor, T, S, D>
+    };
+
+    callers[reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+}
+
+template void reduceRows_gpu<uchar, int, uchar>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<uchar, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<uchar, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+
+template void reduceRows_gpu<ushort, int, ushort>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<ushort, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<ushort, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+
+template void reduceRows_gpu<short, int, short>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<short, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<short, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+
+template void reduceRows_gpu<int, int, int>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceRows_gpu<int, int, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+template void reduceRows_gpu<float, float, float>(const DevMem2Db& src, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+
+
+template <int cn, class Op, typename T, typename S, typename D> __global__ void reduceCols(const DevMem2D_<T> src, D* dst, const Op op)
+{
+    __shared__ S smem[256 * cn];
+
+    const int y = blockIdx.x;
+
+    const T* src_row = src.ptr(y);
+
+    S myVal[cn];
+
+    #pragma unroll
+    for (int c = 0; c < cn; ++c)
+        myVal[c] = op.startValue();
 
 #if __CUDA_ARCH__ >= 200
 
-        // For cc >= 2.0 prefer L1 cache
-        for (int x = threadIdx.x; x < src.cols; x += 256)
-        {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                myVal[c] = op(myVal[c], src_row[x * cn + c]);
-        }
+    // For cc >= 2.0 prefer L1 cache
+    for (int x = threadIdx.x; x < src.cols; x += 256)
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+            myVal[c] = op(myVal[c], src_row[x * cn + c]);
+    }
 
 #else // __CUDA_ARCH__ >= 200
 
-        // For older arch use shared memory for cache
-        for (int x = 0; x < src.cols; x += 256)
+    // For older arch use shared memory for cache
+    for (int x = 0; x < src.cols; x += 256)
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
         {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-            {
-                smem[c * 256 + threadIdx.x] = op.startValue();
-                const int load_x = x * cn + c * 256 + threadIdx.x;
-                if (load_x < src.cols * cn)
-                    smem[c * 256 + threadIdx.x] = src_row[load_x];
-            }
-            __syncthreads();
-
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                myVal[c] = op(myVal[c], smem[threadIdx.x * cn + c]);
-            __syncthreads();
+            smem[c * 256 + threadIdx.x] = op.startValue();
+            const int load_x = x * cn + c * 256 + threadIdx.x;
+            if (load_x < src.cols * cn)
+                smem[c * 256 + threadIdx.x] = src_row[load_x];
         }
-
-#endif // __CUDA_ARCH__ >= 200
+        __syncthreads();
 
         #pragma unroll
         for (int c = 0; c < cn; ++c)
-            smem[c * 256 + threadIdx.x] = myVal[c];
+            myVal[c] = op(myVal[c], smem[threadIdx.x * cn + c]);
         __syncthreads();
-
-        if (threadIdx.x < 128)
-        {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                smem[c * 256 + threadIdx.x] = op(smem[c * 256 + threadIdx.x], smem[c * 256 + threadIdx.x + 128]);
-        }
-        __syncthreads();
-
-        if (threadIdx.x < 64)
-        {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-                smem[c * 256 + threadIdx.x] = op(smem[c * 256 + threadIdx.x], smem[c * 256 + threadIdx.x + 64]);
-        }
-        __syncthreads();
-
-        volatile S* sdata = smem;
-
-        if (threadIdx.x < 32)
-        {
-            #pragma unroll
-            for (int c = 0; c < cn; ++c)
-            {
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 32]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 16]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 8]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 4]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 2]);
-                sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 1]);
-            }
-        }
-        __syncthreads();
-
-        if (threadIdx.x < cn)
-            dst[y * cn + threadIdx.x] = saturate_cast<D>(op.result(smem[threadIdx.x * 256], src.cols));
     }
 
-    template <int cn, template <typename> class Op, typename T, typename S, typename D> void reduceCols_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+#endif // __CUDA_ARCH__ >= 200
+
+    #pragma unroll
+    for (int c = 0; c < cn; ++c)
+        smem[c * 256 + threadIdx.x] = myVal[c];
+    __syncthreads();
+
+    if (threadIdx.x < 128)
     {
-        const dim3 block(256);
-        const dim3 grid(src.rows);
-
-        Op<S> op;
-        reduceCols<cn, Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+            smem[c * 256 + threadIdx.x] = op(smem[c * 256 + threadIdx.x], smem[c * 256 + threadIdx.x + 128]);
     }
+    __syncthreads();
 
-    template <typename T, typename S, typename D> void reduceCols_gpu(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+    if (threadIdx.x < 64)
     {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
-
-        static const caller_t callers[4][4] = 
-        {
-            {reduceCols_caller<1, SumReductor, T, S, D>, reduceCols_caller<1, AvgReductor, T, S, D>, reduceCols_caller<1, MaxReductor, T, S, D>, reduceCols_caller<1, MinReductor, T, S, D>},
-            {reduceCols_caller<2, SumReductor, T, S, D>, reduceCols_caller<2, AvgReductor, T, S, D>, reduceCols_caller<2, MaxReductor, T, S, D>, reduceCols_caller<2, MinReductor, T, S, D>},
-            {reduceCols_caller<3, SumReductor, T, S, D>, reduceCols_caller<3, AvgReductor, T, S, D>, reduceCols_caller<3, MaxReductor, T, S, D>, reduceCols_caller<3, MinReductor, T, S, D>},
-            {reduceCols_caller<4, SumReductor, T, S, D>, reduceCols_caller<4, AvgReductor, T, S, D>, reduceCols_caller<4, MaxReductor, T, S, D>, reduceCols_caller<4, MinReductor, T, S, D>},
-        };
-
-        callers[cn - 1][reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+            smem[c * 256 + threadIdx.x] = op(smem[c * 256 + threadIdx.x], smem[c * 256 + threadIdx.x + 64]);
     }
+    __syncthreads();
 
-    template void reduceCols_gpu<uchar, int, uchar>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceCols_gpu<uchar, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
-    template void reduceCols_gpu<uchar, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+    volatile S* sdata = smem;
 
-    template void reduceCols_gpu<ushort, int, ushort>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
-    template void reduceCols_gpu<ushort, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<ushort, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+    if (threadIdx.x < 32)
+    {
+        #pragma unroll
+        for (int c = 0; c < cn; ++c)
+        {
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 32]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 16]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 8]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 4]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 2]);
+            sdata[c * 256 + threadIdx.x] = op(sdata[c * 256 + threadIdx.x], sdata[c * 256 + threadIdx.x + 1]);
+        }
+    }
+    __syncthreads();
 
-    template void reduceCols_gpu<short, int, short>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
-    template void reduceCols_gpu<short, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<short, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+    if (threadIdx.x < cn)
+        dst[y * cn + threadIdx.x] = saturate_cast<D>(op.result(smem[threadIdx.x * 256], src.cols));
+}
 
-    template void reduceCols_gpu<int, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
-    template void reduceCols_gpu<int, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template <int cn, template <typename> class Op, typename T, typename S, typename D> void reduceCols_caller(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream)
+{
+    const dim3 block(256);
+    const dim3 grid(src.rows);
 
-    template void reduceCols_gpu<float, float, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
- }}}
+    Op<S> op;
+    reduceCols<cn, Op<S>, T, S, D><<<grid, block, 0, stream>>>(src, dst.data, op);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+}
+
+template <typename T, typename S, typename D> void reduceCols_gpu(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, DevMem2D_<D> dst, cudaStream_t stream);
+
+    static const caller_t callers[4][4] = 
+    {
+        {reduceCols_caller<1, SumReductor, T, S, D>, reduceCols_caller<1, AvgReductor, T, S, D>, reduceCols_caller<1, MaxReductor, T, S, D>, reduceCols_caller<1, MinReductor, T, S, D>},
+        {reduceCols_caller<2, SumReductor, T, S, D>, reduceCols_caller<2, AvgReductor, T, S, D>, reduceCols_caller<2, MaxReductor, T, S, D>, reduceCols_caller<2, MinReductor, T, S, D>},
+        {reduceCols_caller<3, SumReductor, T, S, D>, reduceCols_caller<3, AvgReductor, T, S, D>, reduceCols_caller<3, MaxReductor, T, S, D>, reduceCols_caller<3, MinReductor, T, S, D>},
+        {reduceCols_caller<4, SumReductor, T, S, D>, reduceCols_caller<4, AvgReductor, T, S, D>, reduceCols_caller<4, MaxReductor, T, S, D>, reduceCols_caller<4, MinReductor, T, S, D>},
+    };
+
+    callers[cn - 1][reduceOp](static_cast< DevMem2D_<T> >(src), static_cast< DevMem2D_<D> >(dst), stream);
+}
+
+template void reduceCols_gpu<uchar, int, uchar>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<uchar, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+template void reduceCols_gpu<uchar, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+template void reduceCols_gpu<ushort, int, ushort>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream); 
+template void reduceCols_gpu<ushort, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<ushort, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+template void reduceCols_gpu<short, int, short>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+template void reduceCols_gpu<short, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<short, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);  
+
+template void reduceCols_gpu<int, int, int>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);                  
+template void reduceCols_gpu<int, int, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+template void reduceCols_gpu<float, float, float>(const DevMem2Db& src, int cn, const DevMem2Db& dst, int reduceOp, cudaStream_t stream);
+
+} // namespace mattrix_reductions
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/pyr_down.cu

@@ -46,140 +46,142 @@
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace pyr_down {
+
+template <typename T, typename B> __global__ void pyrDown(const PtrStep<T> src, PtrStep<T> dst, const B b, int dst_cols)
 {
-    template <typename T, typename B> __global__ void pyrDown(const PtrStep<T> src, PtrStep<T> dst, const B b, int dst_cols)
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y;
+
+    __shared__ value_type smem[256 + 4];
+
+    value_type sum;
+    
+    const int src_y = 2*y;
+
+    sum = VecTraits<value_type>::all(0);
+    
+    sum = sum + 0.0625f * b.at(src_y - 2, x, src.data, src.step);
+    sum = sum + 0.25f   * b.at(src_y - 1, x, src.data, src.step);
+    sum = sum + 0.375f  * b.at(src_y    , x, src.data, src.step);
+    sum = sum + 0.25f   * b.at(src_y + 1, x, src.data, src.step);
+    sum = sum + 0.0625f * b.at(src_y + 2, x, src.data, src.step);
+
+    smem[2 + threadIdx.x] = sum;
+
+    if (threadIdx.x < 2)
     {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y;
-
-        __shared__ value_type smem[256 + 4];
-
-        value_type sum;
-        
-        const int src_y = 2*y;
+        const int left_x = x - 2 + threadIdx.x;
 
         sum = VecTraits<value_type>::all(0);
-        
-        sum = sum + 0.0625f * b.at(src_y - 2, x, src.data, src.step);
-        sum = sum + 0.25f   * b.at(src_y - 1, x, src.data, src.step);
-        sum = sum + 0.375f  * b.at(src_y    , x, src.data, src.step);
-        sum = sum + 0.25f   * b.at(src_y + 1, x, src.data, src.step);
-        sum = sum + 0.0625f * b.at(src_y + 2, x, src.data, src.step);
+    
+        sum = sum + 0.0625f * b.at(src_y - 2, left_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y - 1, left_x, src.data, src.step);
+        sum = sum + 0.375f  * b.at(src_y    , left_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y + 1, left_x, src.data, src.step);
+        sum = sum + 0.0625f * b.at(src_y + 2, left_x, src.data, src.step);
 
-        smem[2 + threadIdx.x] = sum;
-
-        if (threadIdx.x < 2)
-        {
-            const int left_x = x - 2 + threadIdx.x;
-
-            sum = VecTraits<value_type>::all(0);
-        
-            sum = sum + 0.0625f * b.at(src_y - 2, left_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y - 1, left_x, src.data, src.step);
-            sum = sum + 0.375f  * b.at(src_y    , left_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y + 1, left_x, src.data, src.step);
-            sum = sum + 0.0625f * b.at(src_y + 2, left_x, src.data, src.step);
-
-            smem[threadIdx.x] = sum;
-        }
-
-        if (threadIdx.x > 253)
-        {
-            const int right_x = x + threadIdx.x + 2;
-
-            sum = VecTraits<value_type>::all(0);
-        
-            sum = sum + 0.0625f * b.at(src_y - 2, right_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y - 1, right_x, src.data, src.step);
-            sum = sum + 0.375f  * b.at(src_y    , right_x, src.data, src.step);
-            sum = sum + 0.25f   * b.at(src_y + 1, right_x, src.data, src.step);
-            sum = sum + 0.0625f * b.at(src_y + 2, right_x, src.data, src.step);
-
-            smem[4 + threadIdx.x] = sum;
-        }
-
-        __syncthreads();
-
-        if (threadIdx.x < 128)
-        {
-            const int tid2 = threadIdx.x * 2;
-
-            sum = VecTraits<value_type>::all(0);
-
-            sum = sum + 0.0625f * smem[2 + tid2 - 2];
-            sum = sum + 0.25f   * smem[2 + tid2 - 1];
-            sum = sum + 0.375f  * smem[2 + tid2    ];
-            sum = sum + 0.25f   * smem[2 + tid2 + 1];
-            sum = sum + 0.0625f * smem[2 + tid2 + 2];
-
-            const int dst_x = (blockIdx.x * blockDim.x + tid2) / 2;
-
-            if (dst_x < dst_cols)
-                dst.ptr(y)[dst_x] = saturate_cast<T>(sum);
-        }
+        smem[threadIdx.x] = sum;
     }
 
-    template <typename T, template <typename> class B> void pyrDown_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+    if (threadIdx.x > 253)
     {
-        const dim3 block(256);
-        const dim3 grid(divUp(src.cols, block.x), dst.rows);
+        const int right_x = x + threadIdx.x + 2;
 
-        B<T> b(src.rows, src.cols);
+        sum = VecTraits<value_type>::all(0);
+    
+        sum = sum + 0.0625f * b.at(src_y - 2, right_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y - 1, right_x, src.data, src.step);
+        sum = sum + 0.375f  * b.at(src_y    , right_x, src.data, src.step);
+        sum = sum + 0.25f   * b.at(src_y + 1, right_x, src.data, src.step);
+        sum = sum + 0.0625f * b.at(src_y + 2, right_x, src.data, src.step);
 
-        pyrDown<T><<<grid, block, 0, stream>>>(src, dst, b, dst.cols);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        smem[4 + threadIdx.x] = sum;
     }
 
-    template <typename T, int cn> void pyrDown_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+    __syncthreads();
+
+    if (threadIdx.x < 128)
     {
-        typedef typename TypeVec<T, cn>::vec_type type;
+        const int tid2 = threadIdx.x * 2;
 
-        typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+        sum = VecTraits<value_type>::all(0);
 
-        static const caller_t callers[] = 
-        {
-            pyrDown_caller<type, BrdReflect101>, pyrDown_caller<type, BrdReplicate>, pyrDown_caller<type, BrdConstant>, pyrDown_caller<type, BrdReflect>, pyrDown_caller<type, BrdWrap>
-        };
+        sum = sum + 0.0625f * smem[2 + tid2 - 2];
+        sum = sum + 0.25f   * smem[2 + tid2 - 1];
+        sum = sum + 0.375f  * smem[2 + tid2    ];
+        sum = sum + 0.25f   * smem[2 + tid2 + 1];
+        sum = sum + 0.0625f * smem[2 + tid2 + 2];
 
-        callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
+        const int dst_x = (blockIdx.x * blockDim.x + tid2) / 2;
+
+        if (dst_x < dst_cols)
+            dst.ptr(y)[dst_x] = saturate_cast<T>(sum);
     }
+}
 
-    template void pyrDown_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template <typename T, template <typename> class B> void pyrDown_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    const dim3 block(256);
+    const dim3 grid(divUp(src.cols, block.x), dst.rows);
 
-    template void pyrDown_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+    B<T> b(src.rows, src.cols);
 
-    template void pyrDown_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+    pyrDown<T><<<grid, block, 0, stream>>>(src, dst, b, dst.cols);
+    cudaSafeCall( cudaGetLastError() );
 
-    template void pyrDown_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void pyrDown_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template <typename T, int cn> void pyrDown_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type type;
 
-    template void pyrDown_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrDown_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+    typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
+    {
+        pyrDown_caller<type, BrdReflect101>, pyrDown_caller<type, BrdReplicate>, pyrDown_caller<type, BrdConstant>, pyrDown_caller<type, BrdReflect>, pyrDown_caller<type, BrdWrap>
+    };
+
+    callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
+}
+
+template void pyrDown_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+template void pyrDown_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrDown_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+
+} // namespace pyr_down
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/pyr_up.cu

@@ -46,135 +46,137 @@
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace pyr_up {
+
+template <typename T, typename B> __global__ void pyrUp(const PtrStep<T> src, DevMem2D_<T> dst, const B b)
 {
-    template <typename T, typename B> __global__ void pyrUp(const PtrStep<T> src, DevMem2D_<T> dst, const B b)
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    __shared__ T smem1[10][10];
+    __shared__ value_type smem2[20][16];
+
+    value_type sum;
+
+    if (threadIdx.x < 10 && threadIdx.y < 10)
+        smem1[threadIdx.y][threadIdx.x] = b.at(blockIdx.y * blockDim.y / 2 + threadIdx.y - 1, blockIdx.x * blockDim.x / 2 + threadIdx.x - 1, src.data, src.step);
+
+    __syncthreads();
+
+    const int tidx = threadIdx.x;
+
+    sum = VecTraits<value_type>::all(0);
+
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx - 2) >> 1)];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx - 1) >> 1)];
+    sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[1 + threadIdx.y / 2][1 + ((tidx    ) >> 1)];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx + 1) >> 1)];
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx + 2) >> 1)];
+
+    smem2[2 + threadIdx.y][tidx] = sum;
+
+    if (threadIdx.y < 2)
     {
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type value_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        __shared__ T smem1[10][10];
-        __shared__ value_type smem2[20][16];
-
-        value_type sum;
-
-        if (threadIdx.x < 10 && threadIdx.y < 10)
-            smem1[threadIdx.y][threadIdx.x] = b.at(blockIdx.y * blockDim.y / 2 + threadIdx.y - 1, blockIdx.x * blockDim.x / 2 + threadIdx.x - 1, src.data, src.step);
-
-        __syncthreads();
-
-        const int tidx = threadIdx.x;
-
         sum = VecTraits<value_type>::all(0);
 
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx - 2) >> 1)];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx - 1) >> 1)];
-        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[1 + threadIdx.y / 2][1 + ((tidx    ) >> 1)];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[1 + threadIdx.y / 2][1 + ((tidx + 1) >> 1)];
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[1 + threadIdx.y / 2][1 + ((tidx + 2) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx - 2) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx - 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[0][1 + ((tidx    ) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx + 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx + 2) >> 1)];
 
-        smem2[2 + threadIdx.y][tidx] = sum;
-
-        if (threadIdx.y < 2)
-        {
-            sum = VecTraits<value_type>::all(0);
-
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx - 2) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx - 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[0][1 + ((tidx    ) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[0][1 + ((tidx + 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[0][1 + ((tidx + 2) >> 1)];
-
-            smem2[threadIdx.y][tidx] = sum;
-        }
-
-        if (threadIdx.y > 13)
-        {
-            sum = VecTraits<value_type>::all(0);
-
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx - 2) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx - 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[9][1 + ((tidx    ) >> 1)];
-            sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx + 1) >> 1)];
-            sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx + 2) >> 1)];
-
-            smem2[4 + threadIdx.y][tidx] = sum;
-        }
-
-        __syncthreads();
+        smem2[threadIdx.y][tidx] = sum;
+    }
 
+    if (threadIdx.y > 13)
+    {
         sum = VecTraits<value_type>::all(0);
 
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y - 2][tidx];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y - 1][tidx];
-        sum = sum + (tidx % 2 == 0) * 0.375f  * smem2[2 + threadIdx.y    ][tidx];
-        sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y + 1][tidx];
-        sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y + 2][tidx];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx - 2) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx - 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.375f  * smem1[9][1 + ((tidx    ) >> 1)];
+        sum = sum + (tidx % 2 != 0) * 0.25f   * smem1[9][1 + ((tidx + 1) >> 1)];
+        sum = sum + (tidx % 2 == 0) * 0.0625f * smem1[9][1 + ((tidx + 2) >> 1)];
 
-        if (x < dst.cols && y < dst.rows)
-            dst.ptr(y)[x] = saturate_cast<T>(4.0f * sum);
+        smem2[4 + threadIdx.y][tidx] = sum;
     }
 
-    template <typename T, template <typename> class B> void pyrUp_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+    __syncthreads();
+
+    sum = VecTraits<value_type>::all(0);
+
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y - 2][tidx];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y - 1][tidx];
+    sum = sum + (tidx % 2 == 0) * 0.375f  * smem2[2 + threadIdx.y    ][tidx];
+    sum = sum + (tidx % 2 != 0) * 0.25f   * smem2[2 + threadIdx.y + 1][tidx];
+    sum = sum + (tidx % 2 == 0) * 0.0625f * smem2[2 + threadIdx.y + 2][tidx];
+
+    if (x < dst.cols && y < dst.rows)
+        dst.ptr(y)[x] = saturate_cast<T>(4.0f * sum);
+}
+
+template <typename T, template <typename> class B> void pyrUp_caller(const DevMem2D_<T>& src, const DevMem2D_<T>& dst, cudaStream_t stream)
+{
+    const dim3 block(16, 16);
+    const dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+
+    B<T> b(src.rows, src.cols);
+
+    pyrUp<T><<<grid, block, 0, stream>>>(src, dst, b);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <typename T, int cn> void pyrUp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
+{
+    typedef typename TypeVec<T, cn>::vec_type type;
+
+    typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+
+    static const caller_t callers[] = 
     {
-        const dim3 block(16, 16);
-        const dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        pyrUp_caller<type, BrdReflect101>, pyrUp_caller<type, BrdReplicate>, pyrUp_caller<type, BrdConstant>, pyrUp_caller<type, BrdReflect>, pyrUp_caller<type, BrdWrap>
+    };
 
-        B<T> b(src.rows, src.cols);
+    callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
+}
 
-        pyrUp<T><<<grid, block, 0, stream>>>(src, dst, b);
-        cudaSafeCall( cudaGetLastError() );
+template void pyrUp_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+template void pyrUp_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-    template <typename T, int cn> void pyrUp_gpu(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream)
-    {
-        typedef typename TypeVec<T, cn>::vec_type type;
+template void pyrUp_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        typedef void (*caller_t)(const DevMem2D_<type>& src, const DevMem2D_<type>& dst, cudaStream_t stream);
+template void pyrUp_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        static const caller_t callers[] = 
-        {
-            pyrUp_caller<type, BrdReflect101>, pyrUp_caller<type, BrdReplicate>, pyrUp_caller<type, BrdConstant>, pyrUp_caller<type, BrdReflect>, pyrUp_caller<type, BrdWrap>
-        };
+template void pyrUp_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-        callers[borderType](static_cast< DevMem2D_<type> >(src), static_cast< DevMem2D_<type> >(dst), stream);
-    }
+template void pyrUp_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+template void pyrUp_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
 
-    template void pyrUp_gpu<uchar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<uchar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
+} // namespace pyr_up
 
-    template void pyrUp_gpu<schar, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<schar, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<ushort, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<ushort, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<short, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<short, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<int, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<int, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-
-    template void pyrUp_gpu<float, 1>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 2>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 3>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-    template void pyrUp_gpu<float, 4>(const DevMem2Db& src, const DevMem2Db& dst, int borderType, cudaStream_t stream);
-}}}
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/remap.cu

@@ -47,64 +47,62 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/filters.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace remap {
+    
+template <typename Ptr2D, typename T> __global__ void remap(const Ptr2D src, const PtrStepf mapx, const PtrStepf mapy, DevMem2D_<T> dst)
 {
-    
-    template <typename Ptr2D, typename T> __global__ void remap(const Ptr2D src, const PtrStepf mapx, const PtrStepf mapy, DevMem2D_<T> dst)
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < dst.cols && y < dst.rows)
     {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        const float xcoo = mapx.ptr(y)[x];
+        const float ycoo = mapy.ptr(y)[x];
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = mapx.ptr(y)[x];
-            const float ycoo = mapy.ptr(y)[x];
-
-            dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
-        }
+        dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
     }
+}
 
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherStream
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherStream
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int)
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int)
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
-            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
+        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
-            BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
+        B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
+        BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
 
-            remap<<<grid, block, 0, stream>>>(filter_src, mapx, mapy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherNonStream
+        remap<<<grid, block, 0, stream>>>(filter_src, mapx, mapy, dst);
+        cudaSafeCall( cudaGetLastError() );
+    }
+};
+
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherNonStream
+{
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, const float* borderValue, int)
     {
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, const float* borderValue, int)
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
-            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type; 
+        
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
-            BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
+        B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue));
+        BorderReader< PtrStep<T>, B<work_type> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, B<work_type> > > filter_src(brdSrc);
 
-            remap<<<grid, block>>>(filter_src, mapx, mapy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        remap<<<grid, block>>>(filter_src, mapx, mapy, dst);
+        cudaSafeCall( cudaGetLastError() );
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
 
 #define OPENCV_GPU_IMPLEMENT_REMAP_TEX(type) \
     texture< type , cudaTextureType2D> tex_remap_ ## type (0, cudaFilterModePoint, cudaAddressModeClamp); \
@@ -124,7 +122,7 @@ namespace cv { namespace gpu { namespace imgproc
             typedef typename TypeVec<float, VecTraits< type >::cn>::vec_type work_type; \
             dim3 block(32, cc >= 20 ? 8 : 4); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_remap_ ## type , src); \
+            bindTexture(&tex_remap_ ## type , src); \
             tex_remap_ ## type ##_reader texSrc; \
             B<work_type> brd(src.rows, src.cols, VecTraits<work_type>::make(borderValue)); \
             BorderReader< tex_remap_ ## type ##_reader, B<work_type> > brdSrc(texSrc, brd); \
@@ -140,7 +138,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_remap_ ## type , src); \
+            bindTexture(&tex_remap_ ## type , src); \
             tex_remap_ ## type ##_reader texSrc; \
             Filter< tex_remap_ ## type ##_reader > filter_src(texSrc); \
             remap<<<grid, block>>>(filter_src, mapx, mapy, dst); \
@@ -149,105 +147,108 @@ namespace cv { namespace gpu { namespace imgproc
         } \
     };
     
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar4)
-    
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(schar)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(char2)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(char4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(short)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(short2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(short4)
-    
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int2)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(int4)
-    
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(float)
-    //OPENCV_GPU_IMPLEMENT_REMAP_TEX(float2)
-    OPENCV_GPU_IMPLEMENT_REMAP_TEX(float4)
-    
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(uchar4)
+
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(schar)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(char2)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(char4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(ushort4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(short)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(short2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(short4)
+
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int2)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(int4)
+
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(float)
+//OPENCV_GPU_IMPLEMENT_REMAP_TEX(float2)
+OPENCV_GPU_IMPLEMENT_REMAP_TEX(float4)
+
 #undef OPENCV_GPU_IMPLEMENT_REMAP_TEX
 
-    template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcher
-    { 
-        static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int cc)
-        {
-            if (stream == 0)
-                RemapDispatcherNonStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, cc);
-            else
-                RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc);
+template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcher
+{ 
+    static void call(const DevMem2D_<T>& src, const DevMem2Df& mapx, const DevMem2Df& mapy, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int cc)
+    {
+        if (stream == 0)
+            RemapDispatcherNonStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, cc);
+        else
+            RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc);
+    }
+};
+
+template <typename T> void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, 
+    int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2D_<T>& dst, 
+        const float* borderValue, cudaStream_t stream, int cc);
+
+    static const caller_t callers[3][5] = 
+    {
+        { 
+            RemapDispatcher<PointFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<PointFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<PointFilter, BrdConstant, T>::call, 
+            RemapDispatcher<PointFilter, BrdReflect, T>::call, 
+            RemapDispatcher<PointFilter, BrdWrap, T>::call 
+        },
+        { 
+            RemapDispatcher<LinearFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<LinearFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<LinearFilter, BrdConstant, T>::call, 
+            RemapDispatcher<LinearFilter, BrdReflect, T>::call, 
+            RemapDispatcher<LinearFilter, BrdWrap, T>::call 
+        },
+        { 
+            RemapDispatcher<CubicFilter, BrdReflect101, T>::call, 
+            RemapDispatcher<CubicFilter, BrdReplicate, T>::call, 
+            RemapDispatcher<CubicFilter, BrdConstant, T>::call, 
+            RemapDispatcher<CubicFilter, BrdReflect, T>::call, 
+            RemapDispatcher<CubicFilter, BrdWrap, T>::call 
         }
     };
 
-    template <typename T> void remap_gpu(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, 
-        int borderMode, const float* borderValue, cudaStream_t stream, int cc)
-    {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2D_<T>& dst, 
-            const float* borderValue, cudaStream_t stream, int cc);
+    callers[interpolation][borderMode](static_cast< DevMem2D_<T> >(src), xmap, ymap, static_cast< DevMem2D_<T> >(dst), borderValue, stream, cc);
+}
 
-        static const caller_t callers[3][5] = 
-        {
-            { 
-                RemapDispatcher<PointFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<PointFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<PointFilter, BrdConstant, T>::call, 
-                RemapDispatcher<PointFilter, BrdReflect, T>::call, 
-                RemapDispatcher<PointFilter, BrdWrap, T>::call 
-            },
-            { 
-                RemapDispatcher<LinearFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<LinearFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<LinearFilter, BrdConstant, T>::call, 
-                RemapDispatcher<LinearFilter, BrdReflect, T>::call, 
-                RemapDispatcher<LinearFilter, BrdWrap, T>::call 
-            },
-            { 
-                RemapDispatcher<CubicFilter, BrdReflect101, T>::call, 
-                RemapDispatcher<CubicFilter, BrdReplicate, T>::call, 
-                RemapDispatcher<CubicFilter, BrdConstant, T>::call, 
-                RemapDispatcher<CubicFilter, BrdReflect, T>::call, 
-                RemapDispatcher<CubicFilter, BrdWrap, T>::call 
-            }
-        };
+template void remap_gpu<uchar >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<uchar2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<uchar3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<uchar4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
 
-        callers[interpolation][borderMode](static_cast< DevMem2D_<T> >(src), xmap, ymap, static_cast< DevMem2D_<T> >(dst), borderValue, stream, cc);
-    }
+//template void remap_gpu<schar>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<char4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
 
-    template void remap_gpu<uchar >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<uchar2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<uchar3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<uchar4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    //template void remap_gpu<schar>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<char4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<ushort >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<ushort2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<ushort3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<ushort4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<short >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<short2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<short3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<short4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    //template void remap_gpu<int >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<int4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    
-    template void remap_gpu<float >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    //template void remap_gpu<float2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<float3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-    template void remap_gpu<float4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-}}}
+template void remap_gpu<ushort >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<ushort2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<ushort3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<ushort4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+template void remap_gpu<short >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<short2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<short3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<short4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+//template void remap_gpu<int >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<int4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+template void remap_gpu<float >(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+//template void remap_gpu<float2>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<float3>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+template void remap_gpu<float4>(const DevMem2Db& src, const DevMem2Df& xmap, const DevMem2Df& ymap, const DevMem2Db& dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+
+} // namespace remap
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/resize.cu

@@ -47,102 +47,100 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/filters.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-namespace cv { namespace gpu { namespace imgproc
+namespace resize {
+    
+template <typename Ptr2D, typename T> __global__ void resize(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
 {
-    
-    template <typename Ptr2D, typename T> __global__ void resize(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < dst.cols && y < dst.rows)
     {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        const float xcoo = x / fx;
+        const float ycoo = y / fy;
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = x / fx;
-            const float ycoo = y / fy;
-
-            dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
-        }
+        dst.ptr(y)[x] = saturate_cast<T>(src(ycoo, xcoo));
     }
-    template <typename Ptr2D, typename T> __global__ void resizeNN(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+}
+template <typename Ptr2D, typename T> __global__ void resizeNN(const Ptr2D src, float fx, float fy, DevMem2D_<T> dst)
+{
+    const int x = blockDim.x * blockIdx.x + threadIdx.x;
+    const int y = blockDim.y * blockIdx.y + threadIdx.y;
+
+    if (x < dst.cols && y < dst.rows)
     {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        const float xcoo = x / fx;
+        const float ycoo = y / fy;
 
-        if (x < dst.cols && y < dst.rows)
-        {
-            const float xcoo = x / fx;
-            const float ycoo = y / fy;
-
-            dst.ptr(y)[x] = src(__float2int_rd(ycoo), __float2int_rd(xcoo));
-        }
+        dst.ptr(y)[x] = src(__float2int_rd(ycoo), __float2int_rd(xcoo));
     }
+}
 
-    template <template <typename> class Filter, typename T> struct ResizeDispatcherStream
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+template <template <typename> class Filter, typename T> struct ResizeDispatcherStream
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
 
-            resize<<<grid, block, 0, stream>>>(filter_src, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    template <typename T> struct ResizeDispatcherStream<PointFilter, T>
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        resize<<<grid, block, 0, stream>>>(filter_src, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
+    }
+};
+template <typename T> struct ResizeDispatcherStream<PointFilter, T>
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
 
-            resizeNN<<<grid, block, 0, stream>>>(brdSrc, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
-        }
-    };
-    
-    template <template <typename> class Filter, typename T> struct ResizeDispatcherNonStream
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        resizeNN<<<grid, block, 0, stream>>>(brdSrc, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
+    }
+};
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
-            Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
+template <template <typename> class Filter, typename T> struct ResizeDispatcherNonStream
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            resize<<<grid, block>>>(filter_src, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        Filter< BorderReader< PtrStep<T>, BrdReplicate<T> > > filter_src(brdSrc);
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template <typename T> struct ResizeDispatcherNonStream<PointFilter, T>
-    {
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
-        {            
-            dim3 block(32, 8);
-            dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
+        resize<<<grid, block>>>(filter_src, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
 
-            BrdReplicate<T> brd(src.rows, src.cols);
-            BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
+template <typename T> struct ResizeDispatcherNonStream<PointFilter, T>
+{
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst)
+    {            
+        dim3 block(32, 8);
+        dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y));
 
-            resizeNN<<<grid, block>>>(brdSrc, fx, fy, dst);
-            cudaSafeCall( cudaGetLastError() );
+        BrdReplicate<T> brd(src.rows, src.cols);
+        BorderReader< PtrStep<T>, BrdReplicate<T> > brdSrc(src, brd);
 
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+        resizeNN<<<grid, block>>>(brdSrc, fx, fy, dst);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+};
 
 #define OPENCV_GPU_IMPLEMENT_RESIZE_TEX(type) \
     texture< type , cudaTextureType2D> tex_resize_ ## type (0, cudaFilterModePoint, cudaAddressModeClamp); \
@@ -161,7 +159,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_resize_ ## type , src); \
+            bindTexture(&tex_resize_ ## type , src); \
             tex_resize_ ## type ##_reader texSrc; \
             Filter< tex_resize_ ## type ##_reader > filter_src(texSrc); \
             resize<<<grid, block>>>(filter_src, fx, fy, dst); \
@@ -175,7 +173,7 @@ namespace cv { namespace gpu { namespace imgproc
         { \
             dim3 block(32, 8); \
             dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
-            TextureBinder texHandler(&tex_resize_ ## type , src); \
+            bindTexture(&tex_resize_ ## type , src); \
             tex_resize_ ## type ##_reader texSrc; \
             resizeNN<<<grid, block>>>(texSrc, fx, fy, dst); \
             cudaSafeCall( cudaGetLastError() ); \
@@ -183,82 +181,85 @@ namespace cv { namespace gpu { namespace imgproc
         } \
     };
     
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar4)
-    
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(schar)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char2)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short4)
-    
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int2)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int4)
-    
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float)
-    //OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float2)
-    OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float4)
-    
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(uchar4)
+
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(schar)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char2)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(char4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(ushort4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(short4)
+
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int2)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(int4)
+
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float)
+//OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float2)
+OPENCV_GPU_IMPLEMENT_RESIZE_TEX(float4)
+
 #undef OPENCV_GPU_IMPLEMENT_RESIZE_TEX
 
-    template <template <typename> class Filter, typename T> struct ResizeDispatcher
-    { 
-        static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
-        {
-            if (stream == 0)
-                ResizeDispatcherNonStream<Filter, T>::call(src, fx, fy, dst);
-            else
-                ResizeDispatcherStream<Filter, T>::call(src, fx, fy, dst, stream);
-        }
+template <template <typename> class Filter, typename T> struct ResizeDispatcher
+{ 
+    static void call(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream)
+    {
+        if (stream == 0)
+            ResizeDispatcherNonStream<Filter, T>::call(src, fx, fy, dst);
+        else
+            ResizeDispatcherStream<Filter, T>::call(src, fx, fy, dst, stream);
+    }
+};
+
+template <typename T> void resize_gpu(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream);
+
+    static const caller_t callers[3] = 
+    {
+        ResizeDispatcher<PointFilter, T>::call, ResizeDispatcher<LinearFilter, T>::call, ResizeDispatcher<CubicFilter, T>::call
     };
 
-    template <typename T> void resize_gpu(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream)
-    {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, float fx, float fy, const DevMem2D_<T>& dst, cudaStream_t stream);
+    callers[interpolation](static_cast< DevMem2D_<T> >(src), fx, fy, static_cast< DevMem2D_<T> >(dst), stream);
+}
 
-        static const caller_t callers[3] = 
-        {
-            ResizeDispatcher<PointFilter, T>::call, ResizeDispatcher<LinearFilter, T>::call, ResizeDispatcher<CubicFilter, T>::call
-        };
+template void resize_gpu<uchar >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<uchar2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<uchar3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<uchar4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
 
-        callers[interpolation](static_cast< DevMem2D_<T> >(src), fx, fy, static_cast< DevMem2D_<T> >(dst), stream);
-    }
+//template void resize_gpu<schar>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<char4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
 
-    template void resize_gpu<uchar >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<uchar2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<uchar3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<uchar4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    //template void resize_gpu<schar>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<char4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<ushort >(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<ushort2>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<ushort3>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<ushort4>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<short >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<short2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<short3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<short4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    //template void resize_gpu<int >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<int4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    
-    template void resize_gpu<float >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    //template void resize_gpu<float2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<float3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-    template void resize_gpu<float4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
-}}}
+template void resize_gpu<ushort >(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<ushort2>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<ushort3>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<ushort4>(const DevMem2Db& src,float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+template void resize_gpu<short >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<short2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<short3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<short4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+//template void resize_gpu<int >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<int4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+template void resize_gpu<float >(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+//template void resize_gpu<float2>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<float3>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+template void resize_gpu<float4>(const DevMem2Db& src, float fx, float fy, const DevMem2Db& dst, int interpolation, cudaStream_t stream);
+
+} // namespace resize
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/row_filter.cu

@@ -47,8 +47,7 @@
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
 #define MAX_KERNEL_SIZE 16
 #define BLOCK_DIM_X 16
@@ -56,218 +55,218 @@ using namespace cv::gpu::device;
 #define RESULT_STEPS 8
 #define HALO_STEPS 1
 
-namespace filter_row
+namespace row_filter {
+
+__constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+void loadKernel(const float kernel[], int ksize)
 {
-    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+    cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
+}
 
-    void loadKernel(const float kernel[], int ksize)
+namespace detail
+{
+    template <typename T, size_t size> struct SmemType
     {
-        cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float)) );
-    }
-
-    namespace detail
-    {
-        template <typename T, size_t size> struct SmemType
-        {
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type smem_t;
-        };
-
-        template <typename T> struct SmemType<T, 4>
-        {
-            typedef T smem_t;
-        };
-    }
-
-    template <typename T> struct SmemType
-    {
-        typedef typename detail::SmemType<T, sizeof(T)>::smem_t smem_t;
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type smem_t;
     };
 
-    template <int KERNEL_SIZE, typename T, typename D, typename B>
-    __global__ void linearRowFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
+    template <typename T> struct SmemType<T, 4>
     {
-        typedef typename SmemType<T>::smem_t smem_t;
-        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+        typedef T smem_t;
+    };
+}
 
-        __shared__ smem_t smem[BLOCK_DIM_Y][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_X];
+template <typename T> struct SmemType
+{
+    typedef typename detail::SmemType<T, sizeof(T)>::smem_t smem_t;
+};
 
-        //Offset to the left halo edge
-        const int x = (blockIdx.x * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_X + threadIdx.x;
-        const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
+template <int KERNEL_SIZE, typename T, typename D, typename B>
+__global__ void linearRowFilter(const DevMem2D_<T> src, PtrStep<D> dst, int anchor, const B b)
+{
+    typedef typename SmemType<T>::smem_t smem_t;
+    typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
 
-        if (y < src.rows)
+    __shared__ smem_t smem[BLOCK_DIM_Y][(RESULT_STEPS + 2 * HALO_STEPS) * BLOCK_DIM_X];
+
+    //Offset to the left halo edge
+    const int x = (blockIdx.x * RESULT_STEPS - HALO_STEPS) * BLOCK_DIM_X + threadIdx.x;
+    const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
+
+    if (y < src.rows)
+    {
+        const T* src_row = src.ptr(y);
+
+        //Load main data
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
+
+        //Load left halo
+        #pragma unroll
+        for(int i = 0; i < HALO_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_low(i * BLOCK_DIM_X + x, src_row);
+
+        //Load right halo
+        #pragma unroll
+        for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
+            smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
+
+        __syncthreads();
+
+        D* dst_row = dst.ptr(y);
+
+        #pragma unroll
+        for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
         {
-            const T* src_row = src.ptr(y);
-
-            //Load main data
-            #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
-
-            //Load left halo
-            #pragma unroll
-            for(int i = 0; i < HALO_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_low(i * BLOCK_DIM_X + x, src_row);
-
-            //Load right halo
-            #pragma unroll
-            for(int i = HALO_STEPS + RESULT_STEPS; i < HALO_STEPS + RESULT_STEPS + HALO_STEPS; ++i)
-                smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X] = b.at_high(i * BLOCK_DIM_X + x, src_row);
-
-            __syncthreads();
-
-            D* dst_row = dst.ptr(y);
+            sum_t sum = VecTraits<sum_t>::all(0);
 
             #pragma unroll
-            for(int i = HALO_STEPS; i < HALO_STEPS + RESULT_STEPS; ++i)
-            {
-                sum_t sum = VecTraits<sum_t>::all(0);
+            for (int j = 0; j < KERNEL_SIZE; ++j)
+                sum = sum + smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X + j - anchor] * c_kernel[j];
 
-                #pragma unroll
-                for (int j = 0; j < KERNEL_SIZE; ++j)
-                    sum = sum + smem[threadIdx.y][threadIdx.x + i * BLOCK_DIM_X + j - anchor] * c_kernel[j];
+            int dstX = x + i * BLOCK_DIM_X;
 
-                int dstX = x + i * BLOCK_DIM_X;
-
-                if (dstX < src.cols)
-                    dst_row[dstX] = saturate_cast<D>(sum);
-            }
+            if (dstX < src.cols)
+                dst_row[dstX] = saturate_cast<D>(sum);
         }
     }
 }
 
-namespace cv { namespace gpu { namespace filters
+template <int ksize, typename T, typename D, template<typename> class B>
+void linearRowFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
 {
-    template <int ksize, typename T, typename D, template<typename> class B>
-    void linearRowFilter_caller(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream)
+    typedef typename SmemType<T>::smem_t smem_t;
+
+    const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+    const dim3 grid(divUp(src.cols, RESULT_STEPS * BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y));
+
+    B<smem_t> b(src.cols);
+
+    linearRowFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template <typename T, typename D>
+void linearRowFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
+{
+    typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
+    static const caller_t callers[5][17] = 
     {
-        typedef typename filter_row::SmemType<T>::smem_t smem_t;
-
-        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-        const dim3 grid(divUp(src.cols, RESULT_STEPS * BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y));
-
-        B<smem_t> b(src.cols);
-
-        filter_row::linearRowFilter<ksize, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, b);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-    template <typename T, typename D>
-    void linearRowFilter_gpu(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream)
-    {
-        typedef void (*caller_t)(const DevMem2D_<T>& src, const DevMem2D_<D>& dst, int anchor, cudaStream_t stream);
-        static const caller_t callers[5][17] = 
         {
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<3 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<8 , T, D, BrdRowReflect101>,
-                linearRowFilter_caller<9 , T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<10, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<11, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<12, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<13, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<14, T, D, BrdRowReflect101>,
-                linearRowFilter_caller<15, T, D, BrdRowReflect101>, 
-                linearRowFilter_caller<16, T, D, BrdRowReflect101>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReplicate>,
-                linearRowFilter_caller<3 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<8 , T, D, BrdRowReplicate>,
-                linearRowFilter_caller<9 , T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<10, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<11, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<12, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<13, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<14, T, D, BrdRowReplicate>,
-                linearRowFilter_caller<15, T, D, BrdRowReplicate>, 
-                linearRowFilter_caller<16, T, D, BrdRowReplicate>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<2 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<3 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<4 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<5 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<6 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<7 , T, D, BrdRowConstant>, 
-                linearRowFilter_caller<8 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<9 , T, D, BrdRowConstant>,
-                linearRowFilter_caller<10, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<11, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<12, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<13, T, D, BrdRowConstant>,
-                linearRowFilter_caller<14, T, D, BrdRowConstant>,
-                linearRowFilter_caller<15, T, D, BrdRowConstant>, 
-                linearRowFilter_caller<16, T, D, BrdRowConstant>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<2 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<3 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<4 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<5 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<6 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<7 , T, D, BrdRowReflect>, 
-                linearRowFilter_caller<8 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<9 , T, D, BrdRowReflect>,
-                linearRowFilter_caller<10, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<11, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<12, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<13, T, D, BrdRowReflect>,
-                linearRowFilter_caller<14, T, D, BrdRowReflect>,
-                linearRowFilter_caller<15, T, D, BrdRowReflect>, 
-                linearRowFilter_caller<16, T, D, BrdRowReflect>
-            },
-            {
-                0, 
-                linearRowFilter_caller<1 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<2 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<3 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<4 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<5 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<6 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<7 , T, D, BrdRowWrap>, 
-                linearRowFilter_caller<8 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<9 , T, D, BrdRowWrap>,
-                linearRowFilter_caller<10, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<11, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<12, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<13, T, D, BrdRowWrap>,
-                linearRowFilter_caller<14, T, D, BrdRowWrap>,
-                linearRowFilter_caller<15, T, D, BrdRowWrap>, 
-                linearRowFilter_caller<16, T, D, BrdRowWrap>
-            }
-        };
-        
-        filter_row::loadKernel(kernel, ksize);
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<3 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<8 , T, D, BrdRowReflect101>,
+            linearRowFilter_caller<9 , T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<10, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<11, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<12, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<13, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<14, T, D, BrdRowReflect101>,
+            linearRowFilter_caller<15, T, D, BrdRowReflect101>, 
+            linearRowFilter_caller<16, T, D, BrdRowReflect101>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReplicate>,
+            linearRowFilter_caller<3 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<8 , T, D, BrdRowReplicate>,
+            linearRowFilter_caller<9 , T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<10, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<11, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<12, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<13, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<14, T, D, BrdRowReplicate>,
+            linearRowFilter_caller<15, T, D, BrdRowReplicate>, 
+            linearRowFilter_caller<16, T, D, BrdRowReplicate>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<2 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<3 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<4 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<5 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<6 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<7 , T, D, BrdRowConstant>, 
+            linearRowFilter_caller<8 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<9 , T, D, BrdRowConstant>,
+            linearRowFilter_caller<10, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<11, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<12, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<13, T, D, BrdRowConstant>,
+            linearRowFilter_caller<14, T, D, BrdRowConstant>,
+            linearRowFilter_caller<15, T, D, BrdRowConstant>, 
+            linearRowFilter_caller<16, T, D, BrdRowConstant>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<2 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<3 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<4 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<5 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<6 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<7 , T, D, BrdRowReflect>, 
+            linearRowFilter_caller<8 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<9 , T, D, BrdRowReflect>,
+            linearRowFilter_caller<10, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<11, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<12, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<13, T, D, BrdRowReflect>,
+            linearRowFilter_caller<14, T, D, BrdRowReflect>,
+            linearRowFilter_caller<15, T, D, BrdRowReflect>, 
+            linearRowFilter_caller<16, T, D, BrdRowReflect>
+        },
+        {
+            0, 
+            linearRowFilter_caller<1 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<2 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<3 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<4 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<5 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<6 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<7 , T, D, BrdRowWrap>, 
+            linearRowFilter_caller<8 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<9 , T, D, BrdRowWrap>,
+            linearRowFilter_caller<10, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<11, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<12, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<13, T, D, BrdRowWrap>,
+            linearRowFilter_caller<14, T, D, BrdRowWrap>,
+            linearRowFilter_caller<15, T, D, BrdRowWrap>, 
+            linearRowFilter_caller<16, T, D, BrdRowWrap>
+        }
+    };
+    
+    loadKernel(kernel, ksize);
 
-        callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
-    }
+    callers[brd_type][ksize]((DevMem2D_<T>)src, (DevMem2D_<D>)dst, anchor, stream);
+}
 
-    template void linearRowFilter_gpu<uchar , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<uchar4, float4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearRowFilter_gpu<short , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    //template void linearRowFilter_gpu<short2, float2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<short3, float3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<int   , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-    template void linearRowFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
-}}}
+template void linearRowFilter_gpu<uchar , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<uchar4, float4>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearRowFilter_gpu<short , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+//template void linearRowFilter_gpu<short2, float2>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<short3, float3>(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<int   , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+template void linearRowFilter_gpu<float , float >(const DevMem2Db& src, const DevMem2Db& dst, const float kernel[], int ksize, int anchor, int brd_type, cudaStream_t stream);
+
+} // namespace row_filter
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/safe_call.hpp

@@ -43,9 +43,9 @@
 #ifndef __OPENCV_CUDA_SAFE_CALL_HPP__
 #define __OPENCV_CUDA_SAFE_CALL_HPP__
 
-#include "cuda_runtime_api.h"
-#include "cufft.h"
-#include "cublas.h"
+#include <cuda_runtime_api.h>
+#include <cufft.h>
+#include <cublas.h>
 #include "NCV.hpp"
 
 #if defined(__GNUC__)
@@ -62,46 +62,44 @@
     #define cublasSafeCall(expr)  ___cublasSafeCall(expr, __FILE__, __LINE__)
 #endif
 
-namespace cv
+namespace cv { namespace gpu {
+
+void error(const char *error_string, const char *file, const int line, const char *func = "");
+void nppError(int err, const char *file, const int line, const char *func = "");
+void ncvError(int err, const char *file, const int line, const char *func = "");
+void cufftError(int err, const char *file, const int line, const char *func = "");
+void cublasError(int err, const char *file, const int line, const char *func = "");
+
+static inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
 {
-    namespace gpu
-    {
-        void error(const char *error_string, const char *file, const int line, const char *func = "");
-        void nppError(int err, const char *file, const int line, const char *func = "");
-        void ncvError(int err, const char *file, const int line, const char *func = "");
-        void cufftError(int err, const char *file, const int line, const char *func = "");
-        void cublasError(int err, const char *file, const int line, const char *func = "");
-
-        static inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "")
-        {
-            if (cudaSuccess != err)
-                cv::gpu::error(cudaGetErrorString(err), file, line, func);
-        }
-
-        static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
-        {
-            if (err < 0)
-                cv::gpu::nppError(err, file, line, func);
-        }
-
-        static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
-        {
-            if (NCV_SUCCESS != err)
-                cv::gpu::ncvError(err, file, line, func);
-        }
-
-        static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
-        {
-            if (CUFFT_SUCCESS != err)
-                cv::gpu::cufftError(err, file, line, func);
-        }
-
-        static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
-        {
-            if (CUBLAS_STATUS_SUCCESS != err)
-                cv::gpu::cublasError(err, file, line, func);
-        }
-    }
+    if (cudaSuccess != err)
+        cv::gpu::error(cudaGetErrorString(err), file, line, func);
 }
 
+static inline void ___nppSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (err < 0)
+        cv::gpu::nppError(err, file, line, func);
+}
+
+static inline void ___ncvSafeCall(int err, const char *file, const int line, const char *func = "")
+{
+    if (NCV_SUCCESS != err)
+        cv::gpu::ncvError(err, file, line, func);
+}
+
+static inline void ___cufftSafeCall(cufftResult_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUFFT_SUCCESS != err)
+        cv::gpu::cufftError(err, file, line, func);
+}
+
+static inline void ___cublasSafeCall(cublasStatus_t err, const char *file, const int line, const char *func = "")
+{
+    if (CUBLAS_STATUS_SUCCESS != err)
+        cv::gpu::cublasError(err, file, line, func);
+}
+
+}}
+
 #endif /* __OPENCV_CUDA_SAFE_CALL_HPP__ */

modules/gpu/src/cuda/split_merge.cu

@@ -42,465 +42,467 @@
 
 #include "internal_shared.hpp"
 
-namespace cv { namespace gpu { namespace split_merge {
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-    template <typename T, size_t elem_size = sizeof(T)>
-    struct TypeTraits 
+namespace split_merge {
+
+template <typename T, size_t elem_size = sizeof(T)>
+struct TypeTraits 
+{
+    typedef T type;
+    typedef T type2;
+    typedef T type3;
+    typedef T type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 1>
+{
+    typedef char type;
+    typedef char2 type2;
+    typedef char3 type3;
+    typedef char4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 2>
+{
+    typedef short type;
+    typedef short2 type2;
+    typedef short3 type3;
+    typedef short4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 4> 
+{
+    typedef int type;
+    typedef int2 type2;
+    typedef int3 type3;
+    typedef int4 type4;
+};
+
+template <typename T>
+struct TypeTraits<T, 8> 
+{
+    typedef double type;
+    typedef double2 type2;
+    //typedef double3 type3;
+    //typedef double4 type3;
+};
+
+typedef void (*MergeFunction)(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream);
+typedef void (*SplitFunction)(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream);
+
+//------------------------------------------------------------
+// Merge    
+
+template <typename T>
+__global__ void mergeC2_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type2 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_y[x] = dst_elem;
+    }
+}
+
+
+template <typename T>
+__global__ void mergeC3_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type3 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    const T* src2_y = (const T*)(src2 + y * src2_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_elem.z = src2_y[x];
+        dst_y[x] = dst_elem;
+    }
+}
+
+
+template <>
+__global__ void mergeC3_<double>(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double* src0_y = (const double*)(src0 + y * src0_step);
+    const double* src1_y = (const double*)(src1 + y * src1_step);
+    const double* src2_y = (const double*)(src2 + y * src2_step);
+    double* dst_y = (double*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_y[3 * x] = src0_y[x];
+        dst_y[3 * x + 1] = src1_y[x];
+        dst_y[3 * x + 2] = src2_y[x];
+    }
+}
+
+
+template <typename T>
+__global__ void mergeC4_(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         const uchar* src3, size_t src3_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    typedef typename TypeTraits<T>::type4 dst_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const T* src0_y = (const T*)(src0 + y * src0_step);
+    const T* src1_y = (const T*)(src1 + y * src1_step);
+    const T* src2_y = (const T*)(src2 + y * src2_step);
+    const T* src3_y = (const T*)(src3 + y * src3_step);
+    dst_type* dst_y = (dst_type*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_type dst_elem;
+        dst_elem.x = src0_y[x];
+        dst_elem.y = src1_y[x];
+        dst_elem.z = src2_y[x];
+        dst_elem.w = src3_y[x];
+        dst_y[x] = dst_elem;
+    }
+}
+
+
+template <>
+__global__ void mergeC4_<double>(const uchar* src0, size_t src0_step, 
+                         const uchar* src1, size_t src1_step, 
+                         const uchar* src2, size_t src2_step, 
+                         const uchar* src3, size_t src3_step, 
+                         int rows, int cols, uchar* dst, size_t dst_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double* src0_y = (const double*)(src0 + y * src0_step);
+    const double* src1_y = (const double*)(src1 + y * src1_step);
+    const double* src2_y = (const double*)(src2 + y * src2_step);
+    const double* src3_y = (const double*)(src3 + y * src3_step);
+    double2* dst_y = (double2*)(dst + y * dst_step);
+
+    if (x < cols && y < rows) 
+    {                        
+        dst_y[2 * x] = make_double2(src0_y[x], src1_y[x]);
+        dst_y[2 * x + 1] = make_double2(src2_y[x], src3_y[x]);
+    }
+}
+
+
+template <typename T>
+static void mergeC2_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC2_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void mergeC3_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC3_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            src[2].data, src[2].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void mergeC4_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
+    mergeC4_<T><<<gridDim, blockDim, 0, stream>>>(
+            src[0].data, src[0].step,
+            src[1].data, src[1].step,
+            src[2].data, src[2].step,
+            src[3].data, src[3].step,
+            dst.rows, dst.cols, dst.data, dst.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+void merge_caller(const DevMem2Db* src, DevMem2Db& dst,
+                             int total_channels, size_t elem_size,
+                             const cudaStream_t& stream)
+{
+    static MergeFunction merge_func_tbl[] =
     {
-        typedef T type;
-        typedef T type2;
-        typedef T type3;
-        typedef T type4;
+        mergeC2_<char>, mergeC2_<short>, mergeC2_<int>, 0, mergeC2_<double>,
+        mergeC3_<char>, mergeC3_<short>, mergeC3_<int>, 0, mergeC3_<double>,
+        mergeC4_<char>, mergeC4_<short>, mergeC4_<int>, 0, mergeC4_<double>,
     };
 
-    template <typename T>
-    struct TypeTraits<T, 1>
+    size_t merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
+    MergeFunction merge_func = merge_func_tbl[merge_func_id];
+
+    if (merge_func == 0)
+        cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
+
+    merge_func(src, dst, stream);
+}
+
+
+
+//------------------------------------------------------------
+// Split
+
+
+template <typename T>
+__global__ void splitC2_(const uchar* src, size_t src_step, 
+                        int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step)
+{
+    typedef typename TypeTraits<T>::type2 src_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
+
+    if (x < cols && y < rows) 
     {
-        typedef char type;
-        typedef char2 type2;
-        typedef char3 type3;
-        typedef char4 type4;
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+    }
+}
+
+
+template <typename T>
+__global__ void splitC3_(const uchar* src, size_t src_step, 
+                        int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step,
+                        uchar* dst2, size_t dst2_step)
+{
+    typedef typename TypeTraits<T>::type3 src_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
+    T* dst2_y = (T*)(dst2 + y * dst2_step);
+
+    if (x < cols && y < rows) 
+    {
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+        dst2_y[x] = src_elem.z;
+    }
+}
+
+
+template <>
+__global__ void splitC3_<double>(
+        const uchar* src, size_t src_step, int rows, int cols,
+        uchar* dst0, size_t dst0_step,
+        uchar* dst1, size_t dst1_step,
+        uchar* dst2, size_t dst2_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double* src_y = (const double*)(src + y * src_step);
+    double* dst0_y = (double*)(dst0 + y * dst0_step);
+    double* dst1_y = (double*)(dst1 + y * dst1_step);
+    double* dst2_y = (double*)(dst2 + y * dst2_step);
+
+    if (x < cols && y < rows) 
+    {
+        dst0_y[x] = src_y[3 * x];
+        dst1_y[x] = src_y[3 * x + 1];
+        dst2_y[x] = src_y[3 * x + 2];
+    }
+}
+
+
+template <typename T>
+__global__ void splitC4_(const uchar* src, size_t src_step, int rows, int cols,
+                        uchar* dst0, size_t dst0_step,
+                        uchar* dst1, size_t dst1_step,
+                        uchar* dst2, size_t dst2_step,
+                        uchar* dst3, size_t dst3_step)
+{
+    typedef typename TypeTraits<T>::type4 src_type;
+
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const src_type* src_y = (const src_type*)(src + y * src_step);
+    T* dst0_y = (T*)(dst0 + y * dst0_step);
+    T* dst1_y = (T*)(dst1 + y * dst1_step);
+    T* dst2_y = (T*)(dst2 + y * dst2_step);
+    T* dst3_y = (T*)(dst3 + y * dst3_step);
+
+    if (x < cols && y < rows) 
+    {
+        src_type src_elem = src_y[x];
+        dst0_y[x] = src_elem.x;
+        dst1_y[x] = src_elem.y;
+        dst2_y[x] = src_elem.z;
+        dst3_y[x] = src_elem.w;
+    }
+}
+
+
+template <>
+__global__ void splitC4_<double>(
+        const uchar* src, size_t src_step, int rows, int cols,
+        uchar* dst0, size_t dst0_step,
+        uchar* dst1, size_t dst1_step,
+        uchar* dst2, size_t dst2_step,
+        uchar* dst3, size_t dst3_step)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    const double2* src_y = (const double2*)(src + y * src_step);
+    double* dst0_y = (double*)(dst0 + y * dst0_step);
+    double* dst1_y = (double*)(dst1 + y * dst1_step);
+    double* dst2_y = (double*)(dst2 + y * dst2_step);
+    double* dst3_y = (double*)(dst3 + y * dst3_step);
+
+    if (x < cols && y < rows) 
+    {
+        double2 src_elem1 = src_y[2 * x];
+        double2 src_elem2 = src_y[2 * x + 1];
+        dst0_y[x] = src_elem1.x;
+        dst1_y[x] = src_elem1.y;
+        dst2_y[x] = src_elem2.x;
+        dst3_y[x] = src_elem2.y;
+    }
+}
+
+template <typename T>
+static void splitC2_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC2_<T><<<gridDim, blockDim, 0, stream>>>(
+            src.data, src.step, src.rows, src.cols,
+            dst[0].data, dst[0].step,
+            dst[1].data, dst[1].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void splitC3_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC3_<T><<<gridDim, blockDim, 0, stream>>>(
+            src.data, src.step, src.rows, src.cols,
+            dst[0].data, dst[0].step,
+            dst[1].data, dst[1].step,
+            dst[2].data, dst[2].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+template <typename T>
+static void splitC4_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
+{
+    dim3 blockDim(32, 8);
+    dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
+    splitC4_<T><<<gridDim, blockDim, 0, stream>>>(
+             src.data, src.step, src.rows, src.cols,
+             dst[0].data, dst[0].step,
+             dst[1].data, dst[1].step,
+             dst[2].data, dst[2].step,
+             dst[3].data, dst[3].step);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall(cudaDeviceSynchronize());
+}
+
+
+void split_caller(const DevMem2Db& src, DevMem2Db* dst, int num_channels, size_t elem_size1, const cudaStream_t& stream)
+{
+    static SplitFunction split_func_tbl[] =
+    {
+        splitC2_<char>, splitC2_<short>, splitC2_<int>, 0, splitC2_<double>,
+        splitC3_<char>, splitC3_<short>, splitC3_<int>, 0, splitC3_<double>,
+        splitC4_<char>, splitC4_<short>, splitC4_<int>, 0, splitC4_<double>,
     };
 
-    template <typename T>
-    struct TypeTraits<T, 2>
-    {
-        typedef short type;
-        typedef short2 type2;
-        typedef short3 type3;
-        typedef short4 type4;
-    };
+    size_t split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
+    SplitFunction split_func = split_func_tbl[split_func_id];
 
-    template <typename T>
-    struct TypeTraits<T, 4> 
-    {
-        typedef int type;
-        typedef int2 type2;
-        typedef int3 type3;
-        typedef int4 type4;
-    };
+    if (split_func == 0)
+        cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
 
-    template <typename T>
-    struct TypeTraits<T, 8> 
-    {
-        typedef double type;
-        typedef double2 type2;
-        //typedef double3 type3;
-        //typedef double4 type3;
-    };
+    split_func(src, dst, stream);
+}
 
-    typedef void (*MergeFunction)(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream);
-    typedef void (*SplitFunction)(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream);
+} // namespace split_merge
 
-    //------------------------------------------------------------
-    // Merge    
-
-    template <typename T>
-    __global__ void mergeC2_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type2 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_y[x] = dst_elem;
-        }
-    }
-
-
-    template <typename T>
-    __global__ void mergeC3_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type3 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        const T* src2_y = (const T*)(src2 + y * src2_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_elem.z = src2_y[x];
-            dst_y[x] = dst_elem;
-        }
-    }
-
-
-    template <>
-    __global__ void mergeC3_<double>(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src0_y = (const double*)(src0 + y * src0_step);
-        const double* src1_y = (const double*)(src1 + y * src1_step);
-        const double* src2_y = (const double*)(src2 + y * src2_step);
-        double* dst_y = (double*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_y[3 * x] = src0_y[x];
-            dst_y[3 * x + 1] = src1_y[x];
-            dst_y[3 * x + 2] = src2_y[x];
-        }
-    }
-
-
-    template <typename T>
-    __global__ void mergeC4_(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             const uchar* src3, size_t src3_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        typedef typename TypeTraits<T>::type4 dst_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const T* src0_y = (const T*)(src0 + y * src0_step);
-        const T* src1_y = (const T*)(src1 + y * src1_step);
-        const T* src2_y = (const T*)(src2 + y * src2_step);
-        const T* src3_y = (const T*)(src3 + y * src3_step);
-        dst_type* dst_y = (dst_type*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_type dst_elem;
-            dst_elem.x = src0_y[x];
-            dst_elem.y = src1_y[x];
-            dst_elem.z = src2_y[x];
-            dst_elem.w = src3_y[x];
-            dst_y[x] = dst_elem;
-        }
-    }
-
-
-    template <>
-    __global__ void mergeC4_<double>(const uchar* src0, size_t src0_step, 
-                             const uchar* src1, size_t src1_step, 
-                             const uchar* src2, size_t src2_step, 
-                             const uchar* src3, size_t src3_step, 
-                             int rows, int cols, uchar* dst, size_t dst_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src0_y = (const double*)(src0 + y * src0_step);
-        const double* src1_y = (const double*)(src1 + y * src1_step);
-        const double* src2_y = (const double*)(src2 + y * src2_step);
-        const double* src3_y = (const double*)(src3 + y * src3_step);
-        double2* dst_y = (double2*)(dst + y * dst_step);
-
-        if (x < cols && y < rows) 
-        {                        
-            dst_y[2 * x] = make_double2(src0_y[x], src1_y[x]);
-            dst_y[2 * x + 1] = make_double2(src2_y[x], src3_y[x]);
-        }
-    }
-
-
-    template <typename T>
-    static void mergeC2_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC2_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    template <typename T>
-    static void mergeC3_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC3_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                src[2].data, src[2].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    template <typename T>
-    static void mergeC4_(const DevMem2Db* src, DevMem2Db& dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(dst.cols, blockDim.x), divUp(dst.rows, blockDim.y));
-        mergeC4_<T><<<gridDim, blockDim, 0, stream>>>(
-                src[0].data, src[0].step,
-                src[1].data, src[1].step,
-                src[2].data, src[2].step,
-                src[3].data, src[3].step,
-                dst.rows, dst.cols, dst.data, dst.step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    extern "C" void merge_caller(const DevMem2Db* src, DevMem2Db& dst,
-                                 int total_channels, size_t elem_size,
-                                 const cudaStream_t& stream)
-    {
-        static MergeFunction merge_func_tbl[] =
-        {
-            mergeC2_<char>, mergeC2_<short>, mergeC2_<int>, 0, mergeC2_<double>,
-            mergeC3_<char>, mergeC3_<short>, mergeC3_<int>, 0, mergeC3_<double>,
-            mergeC4_<char>, mergeC4_<short>, mergeC4_<int>, 0, mergeC4_<double>,
-        };
-
-        size_t merge_func_id = (total_channels - 2) * 5 + (elem_size >> 1);
-        MergeFunction merge_func = merge_func_tbl[merge_func_id];
-
-        if (merge_func == 0)
-            cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
-
-        merge_func(src, dst, stream);
-    }
-
-
-
-    //------------------------------------------------------------
-    // Split
-
-
-    template <typename T>
-    __global__ void splitC2_(const uchar* src, size_t src_step, 
-                            int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step)
-    {
-        typedef typename TypeTraits<T>::type2 src_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
-
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-        }
-    }
-
-
-    template <typename T>
-    __global__ void splitC3_(const uchar* src, size_t src_step, 
-                            int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step,
-                            uchar* dst2, size_t dst2_step)
-    {
-        typedef typename TypeTraits<T>::type3 src_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
-        T* dst2_y = (T*)(dst2 + y * dst2_step);
-
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-            dst2_y[x] = src_elem.z;
-        }
-    }
-
-
-    template <>
-    __global__ void splitC3_<double>(
-            const uchar* src, size_t src_step, int rows, int cols,
-            uchar* dst0, size_t dst0_step,
-            uchar* dst1, size_t dst1_step,
-            uchar* dst2, size_t dst2_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double* src_y = (const double*)(src + y * src_step);
-        double* dst0_y = (double*)(dst0 + y * dst0_step);
-        double* dst1_y = (double*)(dst1 + y * dst1_step);
-        double* dst2_y = (double*)(dst2 + y * dst2_step);
-
-        if (x < cols && y < rows) 
-        {
-            dst0_y[x] = src_y[3 * x];
-            dst1_y[x] = src_y[3 * x + 1];
-            dst2_y[x] = src_y[3 * x + 2];
-        }
-    }
-
-
-    template <typename T>
-    __global__ void splitC4_(const uchar* src, size_t src_step, int rows, int cols,
-                            uchar* dst0, size_t dst0_step,
-                            uchar* dst1, size_t dst1_step,
-                            uchar* dst2, size_t dst2_step,
-                            uchar* dst3, size_t dst3_step)
-    {
-        typedef typename TypeTraits<T>::type4 src_type;
-
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const src_type* src_y = (const src_type*)(src + y * src_step);
-        T* dst0_y = (T*)(dst0 + y * dst0_step);
-        T* dst1_y = (T*)(dst1 + y * dst1_step);
-        T* dst2_y = (T*)(dst2 + y * dst2_step);
-        T* dst3_y = (T*)(dst3 + y * dst3_step);
-
-        if (x < cols && y < rows) 
-        {
-            src_type src_elem = src_y[x];
-            dst0_y[x] = src_elem.x;
-            dst1_y[x] = src_elem.y;
-            dst2_y[x] = src_elem.z;
-            dst3_y[x] = src_elem.w;
-        }
-    }
-
-
-    template <>
-    __global__ void splitC4_<double>(
-            const uchar* src, size_t src_step, int rows, int cols,
-            uchar* dst0, size_t dst0_step,
-            uchar* dst1, size_t dst1_step,
-            uchar* dst2, size_t dst2_step,
-            uchar* dst3, size_t dst3_step)
-    {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        const double2* src_y = (const double2*)(src + y * src_step);
-        double* dst0_y = (double*)(dst0 + y * dst0_step);
-        double* dst1_y = (double*)(dst1 + y * dst1_step);
-        double* dst2_y = (double*)(dst2 + y * dst2_step);
-        double* dst3_y = (double*)(dst3 + y * dst3_step);
-
-        if (x < cols && y < rows) 
-        {
-            double2 src_elem1 = src_y[2 * x];
-            double2 src_elem2 = src_y[2 * x + 1];
-            dst0_y[x] = src_elem1.x;
-            dst1_y[x] = src_elem1.y;
-            dst2_y[x] = src_elem2.x;
-            dst3_y[x] = src_elem2.y;
-        }
-    }
-
-    template <typename T>
-    static void splitC2_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC2_<T><<<gridDim, blockDim, 0, stream>>>(
-                src.data, src.step, src.rows, src.cols,
-                dst[0].data, dst[0].step,
-                dst[1].data, dst[1].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    template <typename T>
-    static void splitC3_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC3_<T><<<gridDim, blockDim, 0, stream>>>(
-                src.data, src.step, src.rows, src.cols,
-                dst[0].data, dst[0].step,
-                dst[1].data, dst[1].step,
-                dst[2].data, dst[2].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    template <typename T>
-    static void splitC4_(const DevMem2Db& src, DevMem2Db* dst, const cudaStream_t& stream)
-    {
-        dim3 blockDim(32, 8);
-        dim3 gridDim(divUp(src.cols, blockDim.x), divUp(src.rows, blockDim.y));
-        splitC4_<T><<<gridDim, blockDim, 0, stream>>>(
-                 src.data, src.step, src.rows, src.cols,
-                 dst[0].data, dst[0].step,
-                 dst[1].data, dst[1].step,
-                 dst[2].data, dst[2].step,
-                 dst[3].data, dst[3].step);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall(cudaDeviceSynchronize());
-    }
-
-
-    extern "C" void split_caller(const DevMem2Db& src, DevMem2Db* dst,
-                                 int num_channels, size_t elem_size1,
-                                 const cudaStream_t& stream)
-    {
-        static SplitFunction split_func_tbl[] =
-        {
-            splitC2_<char>, splitC2_<short>, splitC2_<int>, 0, splitC2_<double>,
-            splitC3_<char>, splitC3_<short>, splitC3_<int>, 0, splitC3_<double>,
-            splitC4_<char>, splitC4_<short>, splitC4_<int>, 0, splitC4_<double>,
-        };
-
-        size_t split_func_id = (num_channels - 2) * 5 + (elem_size1 >> 1);
-        SplitFunction split_func = split_func_tbl[split_func_id];
-
-        if (split_func == 0)
-            cv::gpu::error("Unsupported channel count or data type", __FILE__, __LINE__);
-
-        split_func(src, dst, stream);
-    }
-
-}}} // namespace cv::gpu::split_merge
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/stereobm.cu

@@ -40,23 +40,18 @@
 //
 //M*/
 
-//#include "internal_shared.hpp"
-#include "opencv2/gpu/devmem2d.hpp"
-#include "safe_call.hpp"
-static inline int divUp(int total, int grain) { return (total + grain - 1) / grain; }
+#include "internal_shared.hpp"
 
+BEGIN_OPENCV_DEVICE_NAMESPACE
 
-using namespace cv::gpu;
+namespace stereobm {
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////// Streeo BM ////////////////////////////////////////////////
+/////////////////////////////////////// Stereo BM ////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define ROWSperTHREAD 21     // the number of rows a thread will process
 
-namespace cv { namespace gpu  { namespace bm
-{
-
 #define BLOCK_W 128          // the thread block width (464)
 #define N_DISPARITIES 8
 
@@ -117,7 +112,7 @@ __device__ uint2 MinSSD(volatile unsigned int *col_ssd_cache, volatile unsigned
     __syncthreads();
     ssd[7] = CalcSSD<RADIUS>(col_ssd_cache, col_ssd + 7 * (BLOCK_W + 2 * RADIUS));
 
-    int mssd = min(min(min(ssd[0], ssd[1]), min(ssd[4], ssd[5])), min(min(ssd[2], ssd[3]), min(ssd[6], ssd[7])));
+    int mssd = ::min(::min(::min(ssd[0], ssd[1]), ::min(ssd[4], ssd[5])), ::min(::min(ssd[2], ssd[3]), ::min(ssd[6], ssd[7])));
 
     int bestIdx = 0;
     for (int i = 0; i < N_DISPARITIES; i++)
@@ -252,7 +247,7 @@ __global__ void stereoKernel(unsigned char *left, unsigned char *right, size_t i
         for(uint *ptr = minSSDImage; ptr != minSSDImage_end; ptr += minssd_step )
             *ptr = 0xFFFFFFFF;
     }*/
-    int end_row = min(ROWSperTHREAD, cheight - Y - RADIUS);
+    int end_row = ::min(ROWSperTHREAD, cheight - Y - RADIUS);
     int y_tex;
     int x_tex = X - RADIUS;
 
@@ -346,7 +341,7 @@ const static kernel_caller_t callers[] =
 };
 const int calles_num = sizeof(callers)/sizeof(callers[0]);
 
-extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int maxdisp, int winsz, const DevMem2D_<unsigned int>& minSSD_buf, cudaStream_t& stream)
+void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& disp, int maxdisp, int winsz, const DevMem2D_<unsigned int>& minSSD_buf, cudaStream_t& stream)
 {
     int winsz2 = winsz >> 1;
 
@@ -375,7 +370,7 @@ extern "C" void stereoBM_GPU(const DevMem2Db& left, const DevMem2Db& right, cons
 
 texture<unsigned char, 2, cudaReadModeElementType> texForSobel;
 
-extern "C" __global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
+__global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
 {
     int x = blockDim.x * blockIdx.x + threadIdx.x;
     int y = blockDim.y * blockIdx.y + threadIdx.y;
@@ -387,12 +382,12 @@ extern "C" __global__ void prefilter_kernel(DevMem2Db output, int prefilterCap)
                    (int)tex2D(texForSobel, x - 1, y + 1) * (-1) + (int)tex2D(texForSobel, x + 1, y + 1) * (1);
 
 
-        conv = min(min(max(-prefilterCap, conv), prefilterCap) + prefilterCap, 255);
+        conv = ::min(::min(::max(-prefilterCap, conv), prefilterCap) + prefilterCap, 255);
         output.ptr(y)[x] = conv & 0xFF;
     }
 }
 
-extern "C" void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap, cudaStream_t & stream)
+void prefilter_xsobel(const DevMem2Db& input, const DevMem2Db& output, int prefilterCap, cudaStream_t & stream)
 {
     cudaChannelFormatDesc desc = cudaCreateChannelDesc<unsigned char>();
     cudaSafeCall( cudaBindTexture2D( 0, texForSobel, input.data, desc, input.cols, input.rows, input.step ) );
@@ -451,7 +446,7 @@ __device__ float CalcSums(float *cols, float *cols_cache, int winsz)
 
 #define RpT (2 * ROWSperTHREAD)  // got experimentally
 
-extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float threshold)
+__global__ void textureness_kernel(DevMem2Db disp, int winsz, float threshold)
 {
     int winsz2 = winsz/2;
     int n_dirty_pixels = (winsz2) * 2;
@@ -462,7 +457,7 @@ extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float t
 
     int x = blockIdx.x * blockDim.x + threadIdx.x;
     int beg_row = blockIdx.y * RpT;
-    int end_row = min(beg_row + RpT, disp.rows);
+    int end_row = ::min(beg_row + RpT, disp.rows);
 
     if (x < disp.cols)
     {
@@ -510,7 +505,7 @@ extern "C" __global__ void textureness_kernel(DevMem2Db disp, int winsz, float t
     }
 }
 
-extern "C" void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream)
+void postfilter_textureness(const DevMem2Db& input, int winsz, float avgTexturenessThreshold, const DevMem2Db& disp, cudaStream_t & stream)
 {
     avgTexturenessThreshold *= winsz * winsz;
 
@@ -537,4 +532,6 @@ extern "C" void postfilter_textureness(const DevMem2Db& input, int winsz, float
     cudaSafeCall( cudaUnbindTexture (texForTF) );
 }
 
-}}}
+} // namespace stereobm
+
+END_OPENCV_DEVICE_NAMESPACE

modules/gpu/src/cuda/stereobp.cu

@@ -44,484 +44,489 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 
-using namespace cv::gpu;
-using namespace cv::gpu::device;
+BEGIN_OPENCV_DEVICE_NAMESPACE
+
+namespace stereobp {
 
-namespace cv { namespace gpu { namespace bp
-{
 ///////////////////////////////////////////////////////////////
 /////////////////////// load constants ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    __constant__ int   cndisp;
-    __constant__ float cmax_data_term;
-    __constant__ float cdata_weight;
-    __constant__ float cmax_disc_term;
-    __constant__ float cdisc_single_jump;
+__constant__ int   cndisp;
+__constant__ float cmax_data_term;
+__constant__ float cdata_weight;
+__constant__ float cmax_disc_term;
+__constant__ float cdisc_single_jump;
 
-    void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump)
-    {
-        cudaSafeCall( cudaMemcpyToSymbol(cndisp,            &ndisp,            sizeof(int  )) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
-        cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
-    }
+void load_constants(int ndisp, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump)
+{
+    cudaSafeCall( cudaMemcpyToSymbol(cndisp,            &ndisp,            sizeof(int  )) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_data_term,    &max_data_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdata_weight,      &data_weight,      sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cmax_disc_term,    &max_disc_term,    sizeof(float)) );
+    cudaSafeCall( cudaMemcpyToSymbol(cdisc_single_jump, &disc_single_jump, sizeof(float)) );
+}
 
 ///////////////////////////////////////////////////////////////
 ////////////////////////// comp data //////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <int cn> struct PixDiff;
-    template <> struct PixDiff<1>
+template <int cn> struct PixDiff;
+template <> struct PixDiff<1>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *ls;
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            return abs((int)l - *rs);
-        }
-        uchar l;
-    };
-    template <> struct PixDiff<3>
+        l = *ls;
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *((uchar3*)ls);
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            const float tr = 0.299f;
-            const float tg = 0.587f;
-            const float tb = 0.114f;
-
-            float val  = tb * abs((int)l.x - rs[0]);
-                  val += tg * abs((int)l.y - rs[1]);
-                  val += tr * abs((int)l.z - rs[2]);
-
-            return val;
-        }
-        uchar3 l;
-    };
-    template <> struct PixDiff<4>
+        return ::abs((int)l - *rs);
+    }
+    uchar l;
+};
+template <> struct PixDiff<3>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
     {
-        __device__ __forceinline__ PixDiff(const uchar* ls)
-        {
-            l = *((uchar4*)ls);
-        }
-        __device__ __forceinline__ float operator()(const uchar* rs) const
-        {
-            const float tr = 0.299f;
-            const float tg = 0.587f;
-            const float tb = 0.114f;
-
-            uchar4 r = *((uchar4*)rs);
-
-            float val  = tb * abs((int)l.x - r.x);
-                  val += tg * abs((int)l.y - r.y);
-                  val += tr * abs((int)l.z - r.z);
-
-            return val;
-        }
-        uchar4 l;
-    };
-
-    template <int cn, typename D>
-    __global__ void comp_data(const DevMem2Db left, const PtrStepb right, PtrElemStep_<D> data)
+        l = *((uchar3*)ls);
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const float tr = 0.299f;
+        const float tg = 0.587f;
+        const float tb = 0.114f;
 
-        if (y > 0 && y < left.rows - 1 && x > 0 && x < left.cols - 1)
+        float val  = tb * ::abs((int)l.x - rs[0]);
+              val += tg * ::abs((int)l.y - rs[1]);
+              val += tr * ::abs((int)l.z - rs[2]);
+
+        return val;
+    }
+    uchar3 l;
+};
+template <> struct PixDiff<4>
+{
+    __device__ __forceinline__ PixDiff(const uchar* ls)
+    {
+        l = *((uchar4*)ls);
+    }
+    __device__ __forceinline__ float operator()(const uchar* rs) const
+    {
+        const float tr = 0.299f;
+        const float tg = 0.587f;
+        const float tb = 0.114f;
+
+        uchar4 r = *((uchar4*)rs);
+
+        float val  = tb * ::abs((int)l.x - r.x);
+              val += tg * ::abs((int)l.y - r.y);
+              val += tr * ::abs((int)l.z - r.z);
+
+        return val;
+    }
+    uchar4 l;
+};
+
+template <int cn, typename D>
+__global__ void comp_data(const DevMem2Db left, const PtrStepb right, PtrElemStep_<D> data)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y > 0 && y < left.rows - 1 && x > 0 && x < left.cols - 1)
+    {
+        const uchar* ls = left.ptr(y) + x * cn;
+        const PixDiff<cn> pixDiff(ls);
+        const uchar* rs = right.ptr(y) + x * cn;
+
+        D* ds = data.ptr(y) + x;
+        const size_t disp_step = data.step * left.rows;
+
+        for (int disp = 0; disp < cndisp; disp++)
         {
-            const uchar* ls = left.ptr(y) + x * cn;
-            const PixDiff<cn> pixDiff(ls);
-            const uchar* rs = right.ptr(y) + x * cn;
-
-            D* ds = data.ptr(y) + x;
-            const size_t disp_step = data.step * left.rows;
-
-            for (int disp = 0; disp < cndisp; disp++)
+            if (x - disp >= 1)
             {
-                if (x - disp >= 1)
-                {
-                    float val = pixDiff(rs - disp * cn);
+                float val = pixDiff(rs - disp * cn);
 
-                    ds[disp * disp_step] = saturate_cast<D>(fmin(cdata_weight * val, cdata_weight * cmax_data_term));
-                }
-                else
-                {
-                    ds[disp * disp_step] = saturate_cast<D>(cdata_weight * cmax_data_term);
-                }
+                ds[disp * disp_step] = saturate_cast<D>(fmin(cdata_weight * val, cdata_weight * cmax_data_term));
+            }
+            else
+            {
+                ds[disp * disp_step] = saturate_cast<D>(cdata_weight * cmax_data_term);
             }
         }
     }
+}
 
-    template<typename T, typename D>
-    void comp_data_gpu(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream);
+template<typename T, typename D>
+void comp_data_gpu(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream);
 
-    template <> void comp_data_gpu<uchar, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<1, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<1, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<1, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<1, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <> void comp_data_gpu<uchar3, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar3, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<3, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<3, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar3, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar3, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<3, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<3, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template <> void comp_data_gpu<uchar4, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <> void comp_data_gpu<uchar4, short>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<4, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<4, short><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<short>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-    template <> void comp_data_gpu<uchar4, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+template <> void comp_data_gpu<uchar4, float>(const DevMem2Db& left, const DevMem2Db& right, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(left.cols, threads.x);
-        grid.y = divUp(left.rows, threads.y);
+    grid.x = divUp(left.cols, threads.x);
+    grid.y = divUp(left.rows, threads.y);
 
-        comp_data<4, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
-        cudaSafeCall( cudaGetLastError() );
+    comp_data<4, float><<<grid, threads, 0, stream>>>(left, right, (DevMem2D_<float>)data);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
 ///////////////////////////////////////////////////////////////
 //////////////////////// data step down ///////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __global__ void data_step_down(int dst_cols, int dst_rows, int src_rows, const PtrStep<T> src, PtrStep<T> dst)
+template <typename T>
+__global__ void data_step_down(int dst_cols, int dst_rows, int src_rows, const PtrStep<T> src, PtrStep<T> dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (x < dst_cols && y < dst_rows)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (x < dst_cols && y < dst_rows)
+        for (int d = 0; d < cndisp; ++d)
         {
-            for (int d = 0; d < cndisp; ++d)
-            {
-                float dst_reg  = src.ptr(d * src_rows + (2*y+0))[(2*x+0)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+0)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+0))[(2*x+1)];
-                      dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+1)];
+            float dst_reg  = src.ptr(d * src_rows + (2*y+0))[(2*x+0)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+0)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+0))[(2*x+1)];
+                  dst_reg += src.ptr(d * src_rows + (2*y+1))[(2*x+1)];
 
-                dst.ptr(d * dst_rows + y)[x] = saturate_cast<T>(dst_reg);
-            }
+            dst.ptr(d * dst_rows + y)[x] = saturate_cast<T>(dst_reg);
         }
     }
+}
 
-    template<typename T>
-    void data_step_down_gpu(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template<typename T>
+void data_step_down_gpu(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(dst_cols, threads.x);
-        grid.y = divUp(dst_rows, threads.y);
+    grid.x = divUp(dst_cols, threads.x);
+    grid.y = divUp(dst_rows, threads.y);
 
-        data_step_down<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)src, (DevMem2D_<T>)dst);
-        cudaSafeCall( cudaGetLastError() );
+    data_step_down<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)src, (DevMem2D_<T>)dst);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
 
-    template void data_step_down_gpu<short>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
-    template void data_step_down_gpu<float>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
+template void data_step_down_gpu<short>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
+template void data_step_down_gpu<float>(int dst_cols, int dst_rows, int src_rows, const DevMem2Db& src, const DevMem2Db& dst, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 /////////////////// level up messages  ////////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __global__ void level_up_message(int dst_cols, int dst_rows, int src_rows, const PtrElemStep_<T> src, PtrElemStep_<T> dst)
+template <typename T>
+__global__ void level_up_message(int dst_cols, int dst_rows, int src_rows, const PtrElemStep_<T> src, PtrElemStep_<T> dst)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (x < dst_cols && y < dst_rows)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const size_t dst_disp_step = dst.step * dst_rows;
+        const size_t src_disp_step = src.step * src_rows;
 
-        if (x < dst_cols && y < dst_rows)
-        {
-            const size_t dst_disp_step = dst.step * dst_rows;
-            const size_t src_disp_step = src.step * src_rows;
+        T*       dstr = dst.ptr(y  ) + x;
+        const T* srcr = src.ptr(y/2) + x/2;
 
-            T*       dstr = dst.ptr(y  ) + x;
-            const T* srcr = src.ptr(y/2) + x/2;
-
-            for (int d = 0; d < cndisp; ++d)
-                dstr[d * dst_disp_step] = srcr[d * src_disp_step];
-        }
+        for (int d = 0; d < cndisp; ++d)
+            dstr[d * dst_disp_step] = srcr[d * src_disp_step];
     }
+}
 
-    template <typename T>
-    void level_up_messages_gpu(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+template <typename T>
+void level_up_messages_gpu(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-        grid.x = divUp(dst_cols, threads.x);
-        grid.y = divUp(dst_rows, threads.y);
+    grid.x = divUp(dst_cols, threads.x);
+    grid.y = divUp(dst_rows, threads.y);
 
-        int src_idx = (dst_idx + 1) & 1;
+    int src_idx = (dst_idx + 1) & 1;
 
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mus[src_idx], (DevMem2D_<T>)mus[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mds[src_idx], (DevMem2D_<T>)mds[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mls[src_idx], (DevMem2D_<T>)mls[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
-        level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mrs[src_idx], (DevMem2D_<T>)mrs[dst_idx]);
-        cudaSafeCall( cudaGetLastError() );
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mus[src_idx], (DevMem2D_<T>)mus[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
 
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mds[src_idx], (DevMem2D_<T>)mds[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
 
-    template void level_up_messages_gpu<short>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
-    template void level_up_messages_gpu<float>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mls[src_idx], (DevMem2D_<T>)mls[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
+
+    level_up_message<T><<<grid, threads, 0, stream>>>(dst_cols, dst_rows, src_rows, (DevMem2D_<T>)mrs[src_idx], (DevMem2D_<T>)mrs[dst_idx]);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template void level_up_messages_gpu<short>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
+template void level_up_messages_gpu<float>(int dst_idx, int dst_cols, int dst_rows, int src_rows, DevMem2Db* mus, DevMem2Db* mds, DevMem2Db* mls, DevMem2Db* mrs, cudaStream_t stream);
 
 ///////////////////////////////////////////////////////////////
 ////////////////////  calc all iterations /////////////////////
 ///////////////////////////////////////////////////////////////
 
-    template <typename T>
-    __device__ void calc_min_linear_penalty(T* dst, size_t step)
+template <typename T>
+__device__ void calc_min_linear_penalty(T* dst, size_t step)
+{
+    float prev = dst[0];
+    float cur;
+    for (int disp = 1; disp < cndisp; ++disp)
     {
-        float prev = dst[0];
-        float cur;
-        for (int disp = 1; disp < cndisp; ++disp)
+        prev += cdisc_single_jump;
+        cur = dst[step * disp];
+        if (prev < cur)
         {
-            prev += cdisc_single_jump;
-            cur = dst[step * disp];
-            if (prev < cur)
-            {
-                cur = prev;
-                dst[step * disp] = saturate_cast<T>(prev);
-            }
-            prev = cur;
-        }
-
-        prev = dst[(cndisp - 1) * step];
-        for (int disp = cndisp - 2; disp >= 0; disp--)
-        {
-            prev += cdisc_single_jump;
-            cur = dst[step * disp];
-            if (prev < cur)
-            {
-                cur = prev;
-                dst[step * disp] = saturate_cast<T>(prev);
-            }
-            prev = cur;
+            cur = prev;
+            dst[step * disp] = saturate_cast<T>(prev);
         }
+        prev = cur;
     }
 
-    template <typename T>
-    __device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
+    prev = dst[(cndisp - 1) * step];
+    for (int disp = cndisp - 2; disp >= 0; disp--)
     {
-        float minimum = numeric_limits<float>::max();
-
-        for(int i = 0; i < cndisp; ++i)
+        prev += cdisc_single_jump;
+        cur = dst[step * disp];
+        if (prev < cur)
         {
-            float dst_reg  = msg1[msg_disp_step * i];
-                  dst_reg += msg2[msg_disp_step * i];
-                  dst_reg += msg3[msg_disp_step * i];
-                  dst_reg += data[data_disp_step * i];
-
-            if (dst_reg < minimum)
-                minimum = dst_reg;
-
-            dst[msg_disp_step * i] = saturate_cast<T>(dst_reg);
+            cur = prev;
+            dst[step * disp] = saturate_cast<T>(prev);
         }
+        prev = cur;
+    }
+}
 
-        calc_min_linear_penalty(dst, msg_disp_step);
+template <typename T>
+__device__ void message(const T* msg1, const T* msg2, const T* msg3, const T* data, T* dst, size_t msg_disp_step, size_t data_disp_step)
+{
+    float minimum = device::numeric_limits<float>::max();
 
-        minimum += cmax_disc_term;
+    for(int i = 0; i < cndisp; ++i)
+    {
+        float dst_reg  = msg1[msg_disp_step * i];
+              dst_reg += msg2[msg_disp_step * i];
+              dst_reg += msg3[msg_disp_step * i];
+              dst_reg += data[data_disp_step * i];
 
-        float sum = 0;
-        for(int i = 0; i < cndisp; ++i)
-        {
-            float dst_reg = dst[msg_disp_step * i];
-            if (dst_reg > minimum)
-            {
-                dst_reg = minimum;
-                dst[msg_disp_step * i] = saturate_cast<T>(minimum);
-            }
-            sum += dst_reg;
-        }
-        sum /= cndisp;
+        if (dst_reg < minimum)
+            minimum = dst_reg;
 
-        for(int i = 0; i < cndisp; ++i)
-            dst[msg_disp_step * i] -= sum;
+        dst[msg_disp_step * i] = saturate_cast<T>(dst_reg);
     }
 
-    template <typename T>
-    __global__ void one_iteration(int t, PtrElemStep_<T> u, T* d, T* l, T* r, const PtrElemStep_<T> data, int cols, int rows)
-    {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+    calc_min_linear_penalty(dst, msg_disp_step);
 
-        if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1))
+    minimum += cmax_disc_term;
+
+    float sum = 0;
+    for(int i = 0; i < cndisp; ++i)
+    {
+        float dst_reg = dst[msg_disp_step * i];
+        if (dst_reg > minimum)
         {
-            T* us = u.ptr(y) + x;
-            T* ds = d + y * u.step + x;
-            T* ls = l + y * u.step + x;
-            T* rs = r + y * u.step + x;
-            const T* dt = data.ptr(y) + x;
-
-            size_t msg_disp_step = u.step * rows;
-            size_t data_disp_step = data.step * rows;
-
-            message(us + u.step, ls      + 1, rs - 1, dt, us, msg_disp_step, data_disp_step);
-            message(ds - u.step, ls      + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step);
-            message(us + u.step, ds - u.step, rs - 1, dt, rs, msg_disp_step, data_disp_step);
-            message(us + u.step, ds - u.step, ls + 1, dt, ls, msg_disp_step, data_disp_step);
+            dst_reg = minimum;
+            dst[msg_disp_step * i] = saturate_cast<T>(minimum);
         }
+        sum += dst_reg;
     }
+    sum /= cndisp;
 
-    template <typename T>
-    void calc_all_iterations_gpu(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d,
-        const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream)
+    for(int i = 0; i < cndisp; ++i)
+        dst[msg_disp_step * i] -= sum;
+}
+
+template <typename T>
+__global__ void one_iteration(int t, PtrElemStep_<T> u, T* d, T* l, T* r, const PtrElemStep_<T> data, int cols, int rows)
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = ((blockIdx.x * blockDim.x + threadIdx.x) << 1) + ((y + t) & 1);
+
+    if ((y > 0) && (y < rows - 1) && (x > 0) && (x < cols - 1))
     {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
+        T* us = u.ptr(y) + x;
+        T* ds = d + y * u.step + x;
+        T* ls = l + y * u.step + x;
+        T* rs = r + y * u.step + x;
+        const T* dt = data.ptr(y) + x;
 
-        grid.x = divUp(cols, threads.x << 1);
-        grid.y = divUp(rows, threads.y);
+        size_t msg_disp_step = u.step * rows;
+        size_t data_disp_step = data.step * rows;
 
-        for(int t = 0; t < iters; ++t)
-        {
-            one_iteration<T><<<grid, threads, 0, stream>>>(t, (DevMem2D_<T>)u, (T*)d.data, (T*)l.data, (T*)r.data, (DevMem2D_<T>)data, cols, rows);
-            cudaSafeCall( cudaGetLastError() );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
+        message(us + u.step, ls      + 1, rs - 1, dt, us, msg_disp_step, data_disp_step);
+        message(ds - u.step, ls      + 1, rs - 1, dt, ds, msg_disp_step, data_disp_step);
+        message(us + u.step, ds - u.step, rs - 1, dt, rs, msg_disp_step, data_disp_step);
+        message(us + u.step, ds - u.step, ls + 1, dt, ls, msg_disp_step, data_disp_step);
     }
+}
 
-    template void calc_all_iterations_gpu<short>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
-    template void calc_all_iterations_gpu<float>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
+template <typename T>
+void calc_all_iterations_gpu(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d,
+    const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
 
-///////////////////////////////////////////////////////////////
-/////////////////////////// output ////////////////////////////
-///////////////////////////////////////////////////////////////
+    grid.x = divUp(cols, threads.x << 1);
+    grid.y = divUp(rows, threads.y);
 
-    template <typename T>
-    __global__ void output(const PtrElemStep_<T> u, const T* d, const T* l, const T* r, const T* data,
-        DevMem2D_<short> disp)
+    for(int t = 0; t < iters; ++t)
     {
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-        if (y > 0 && y < disp.rows - 1 && x > 0 && x < disp.cols - 1)
-        {
-            const T* us = u.ptr(y + 1) + x;
-            const T* ds = d + (y - 1) * u.step + x;
-            const T* ls = l + y * u.step + (x + 1);
-            const T* rs = r + y * u.step + (x - 1);
-            const T* dt = data + y * u.step + x;
-
-            size_t disp_step = disp.rows * u.step;
-
-            int best = 0;
-            float best_val = numeric_limits<float>::max();
-            for (int d = 0; d < cndisp; ++d)
-            {
-                float val  = us[d * disp_step];
-                      val += ds[d * disp_step];
-                      val += ls[d * disp_step];
-                      val += rs[d * disp_step];
-                      val += dt[d * disp_step];
-
-                if (val < best_val)
-                {
-                    best_val = val;
-                    best = d;
-                }
-            }
-
-            disp.ptr(y)[x] = saturate_cast<short>(best);
-        }
-    }
-
-    template <typename T>
-    void output_gpu(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data,
-        const DevMem2D_<short>& disp, cudaStream_t stream)
-    {
-        dim3 threads(32, 8, 1);
-        dim3 grid(1, 1, 1);
-
-        grid.x = divUp(disp.cols, threads.x);
-        grid.y = divUp(disp.rows, threads.y);
-
-        output<T><<<grid, threads, 0, stream>>>((DevMem2D_<T>)u, (const T*)d.data, (const T*)l.data, (const T*)r.data, (const T*)data.data, disp);
+        one_iteration<T><<<grid, threads, 0, stream>>>(t, (DevMem2D_<T>)u, (T*)d.data, (T*)l.data, (T*)r.data, (DevMem2D_<T>)data, cols, rows);
         cudaSafeCall( cudaGetLastError() );
 
         if (stream == 0)
             cudaSafeCall( cudaDeviceSynchronize() );
     }
+}
 
-    template void output_gpu<short>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
-    template void output_gpu<float>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
-}}}
+template void calc_all_iterations_gpu<short>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
+template void calc_all_iterations_gpu<float>(int cols, int rows, int iters, const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, cudaStream_t stream);
+
+///////////////////////////////////////////////////////////////
+/////////////////////////// output ////////////////////////////
+///////////////////////////////////////////////////////////////
+
+template <typename T>
+__global__ void output(const PtrElemStep_<T> u, const T* d, const T* l, const T* r, const T* data,
+    DevMem2D_<short> disp)
+{
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+    if (y > 0 && y < disp.rows - 1 && x > 0 && x < disp.cols - 1)
+    {
+        const T* us = u.ptr(y + 1) + x;
+        const T* ds = d + (y - 1) * u.step + x;
+        const T* ls = l + y * u.step + (x + 1);
+        const T* rs = r + y * u.step + (x - 1);
+        const T* dt = data + y * u.step + x;
+
+        size_t disp_step = disp.rows * u.step;
+
+        int best = 0;
+        float best_val = numeric_limits<float>::max();
+        for (int d = 0; d < cndisp; ++d)
+        {
+            float val  = us[d * disp_step];
+                  val += ds[d * disp_step];
+                  val += ls[d * disp_step];
+                  val += rs[d * disp_step];
+                  val += dt[d * disp_step];
+
+            if (val < best_val)
+            {
+                best_val = val;
+                best = d;
+            }
+        }
+
+        disp.ptr(y)[x] = saturate_cast<short>(best);
+    }
+}
+
+template <typename T>
+void output_gpu(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data,
+    const DevMem2D_<short>& disp, cudaStream_t stream)
+{
+    dim3 threads(32, 8, 1);
+    dim3 grid(1, 1, 1);
+
+    grid.x = divUp(disp.cols, threads.x);
+    grid.y = divUp(disp.rows, threads.y);
+
+    output<T><<<grid, threads, 0, stream>>>((DevMem2D_<T>)u, (const T*)d.data, (const T*)l.data, (const T*)r.data, (const T*)data.data, disp);
+    cudaSafeCall( cudaGetLastError() );
+
+    if (stream == 0)
+        cudaSafeCall( cudaDeviceSynchronize() );
+}
+
+template void output_gpu<short>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
+template void output_gpu<float>(const DevMem2Db& u, const DevMem2Db& d, const DevMem2Db& l, const DevMem2Db& r, const DevMem2Db& data, const DevMem2D_<short>& disp, cudaStream_t stream);
+
+} // namespace stereobp
+
+END_OPENCV_DEVICE_NAMESPACE