removed BEGIN_OPENCV_DEVICE_NAMESPACE macros

modules/gpu/src/arithm.cpp

@@ -425,21 +425,20 @@ void cv::gpu::magnitudeSqr(const GpuMat& src, GpuMat& dst, Stream& stream)
 ////////////////////////////////////////////////////////////////////////
 // Polar <-> Cart
 
-BEGIN_OPENCV_DEVICE_NAMESPACE
-
-namespace mathfunc 
+namespace cv { namespace gpu { namespace device 
 {
-    void cartToPolar_gpu(DevMem2Df x, DevMem2Df y, DevMem2Df mag, bool magSqr, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream);
-    void polarToCart_gpu(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream);
-}
-
-END_OPENCV_DEVICE_NAMESPACE
+    namespace mathfunc 
+    {
+        void cartToPolar_gpu(DevMem2Df x, DevMem2Df y, DevMem2Df mag, bool magSqr, DevMem2Df angle, bool angleInDegrees, cudaStream_t stream);
+        void polarToCart_gpu(DevMem2Df mag, DevMem2Df angle, DevMem2Df x, DevMem2Df y, bool angleInDegrees, cudaStream_t stream);
+    }
+}}}
 
 namespace
 {
     inline void cartToPolar_caller(const GpuMat& x, const GpuMat& y, GpuMat* mag, bool magSqr, GpuMat* angle, bool angleInDegrees, cudaStream_t stream)
     {
-        using namespace OPENCV_DEVICE_NAMESPACE_ mathfunc;
+        using namespace ::cv::gpu::device::mathfunc;
 
         CV_DbgAssert(x.size() == y.size() && x.type() == y.type());
         CV_Assert(x.depth() == CV_32F);
@@ -459,7 +458,7 @@ namespace
 
     inline void polarToCart_caller(const GpuMat& mag, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, cudaStream_t stream)
     {
-        using namespace OPENCV_DEVICE_NAMESPACE_ mathfunc;
+        using namespace ::cv::gpu::device::mathfunc;
 
         CV_DbgAssert((mag.empty() || mag.size() == angle.size()) && mag.type() == angle.type());
         CV_Assert(mag.depth() == CV_32F);

modules/gpu/src/bilateral_filter.cpp

@@ -55,19 +55,18 @@ void cv::gpu::DisparityBilateralFilter::operator()(const GpuMat&, const GpuMat&,
 
 #else /* !defined (HAVE_CUDA) */
 
-BEGIN_OPENCV_DEVICE_NAMESPACE
-
-namespace bilateral_filter
+namespace cv { namespace gpu { namespace device 
 {
-    void load_constants(float* table_color, DevMem2Df table_space, int ndisp, int radius, short edge_disc, short max_disc);
-
-    void bilateral_filter_gpu(DevMem2Db disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
-    void bilateral_filter_gpu(DevMem2D_<short> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
-}
+    namespace bilateral_filter
+    {
+        void load_constants(float* table_color, DevMem2Df table_space, int ndisp, int radius, short edge_disc, short max_disc);
 
-END_OPENCV_DEVICE_NAMESPACE
+        void bilateral_filter_gpu(DevMem2Db disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
+        void bilateral_filter_gpu(DevMem2D_<short> disp, DevMem2Db img, int channels, int iters, cudaStream_t stream);
+    }
+}}}
 
-using namespace OPENCV_DEVICE_NAMESPACE_ bilateral_filter;
+using namespace ::cv::gpu::device::bilateral_filter;
 
 namespace
 {

modules/gpu/src/blend.cpp

@@ -52,19 +52,18 @@ void cv::gpu::blendLinear(const GpuMat&, const GpuMat&, const GpuMat&, const Gpu
 
 #else
 
-BEGIN_OPENCV_DEVICE_NAMESPACE
-
-namespace blend
+namespace cv { namespace gpu { namespace device 
 {
-    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);
-
-    void blendLinearCaller8UC4(int rows, int cols, PtrStepb img1, PtrStepb img2, PtrStepf weights1, PtrStepf weights2, PtrStepb result, cudaStream_t stream);
-}
+    namespace blend
+    {
+        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);
 
-END_OPENCV_DEVICE_NAMESPACE
+        void blendLinearCaller8UC4(int rows, int cols, PtrStepb img1, PtrStepb img2, PtrStepf weights1, PtrStepf weights2, PtrStepb result, cudaStream_t stream);
+    }
+}}}
 
-using namespace OPENCV_DEVICE_NAMESPACE_ blend;
+using namespace ::cv::gpu::device::blend;
 
 void cv::gpu::blendLinear(const GpuMat& img1, const GpuMat& img2, const GpuMat& weights1, const GpuMat& weights2, 
                           GpuMat& result, Stream& stream)

modules/gpu/src/calib3d.cpp

@@ -56,31 +56,30 @@ void cv::gpu::solvePnPRansac(const Mat&, const Mat&, const Mat&, const Mat&, Mat
 
 #else
 
-BEGIN_OPENCV_DEVICE_NAMESPACE
-
-namespace transform_points 
-{
-    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, DevMem2D_<float3> dst, cudaStream_t stream);
-}
-
-namespace project_points 
+namespace cv { namespace gpu { namespace device 
 {
-    void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
-}
+    namespace transform_points 
+    {
+        void call(const DevMem2D_<float3> src, const float* rot, const float* transl, DevMem2D_<float3> dst, cudaStream_t stream);
+    }
 
-namespace solve_pnp_ransac
-{
-    int maxNumIters();
+    namespace project_points 
+    {
+        void call(const DevMem2D_<float3> src, const float* rot, const float* transl, const float* proj, DevMem2D_<float2> dst, cudaStream_t stream);
+    }
 
-    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);
-}
+    namespace solve_pnp_ransac
+    {
+        int maxNumIters();
 
-END_OPENCV_DEVICE_NAMESPACE
+        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);
+    }
+}}}
 
-using namespace OPENCV_DEVICE_NAMESPACE;
+using namespace ::cv::gpu::device;
 
 namespace
 {

modules/gpu/src/cuda/blend.cu

@@ -42,77 +42,75 @@
 
 #include "internal_shared.hpp"
 
-BEGIN_OPENCV_DEVICE_NAMESPACE
-
-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)
+namespace cv { namespace gpu { namespace device 
 {
-    int x = blockIdx.x * blockDim.x + threadIdx.x;
-    int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-    if (y < rows && x < cols)
+    namespace blend 
     {
-        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, 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() );
+        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;
 
-    if (stream == 0)
-        cudaSafeCall(cudaDeviceSynchronize());
-}
+            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 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);
+        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());
+        }
 
-__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;
+        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);
 
-    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);
-    }
-}
 
-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() );
+        __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 (stream == 0)
-        cudaSafeCall(cudaDeviceSynchronize());
-}
+            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);
+            }
+        }
 
-} // namespace blend 
+        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() );
 
-END_OPENCV_DEVICE_NAMESPACE
+            if (stream == 0)
+                cudaSafeCall(cudaDeviceSynchronize());
+        }
+    } // namespace blend 
+}}} // namespace cv { namespace gpu { namespace device

modules/gpu/src/cuda/safe_call.hpp

@@ -62,44 +62,43 @@
     #define cublasSafeCall(expr)  ___cublasSafeCall(expr, __FILE__, __LINE__)
 #endif
 
-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 cv { namespace gpu 
 {
-    if (cudaSuccess != err)
-        cv::gpu::error(cudaGetErrorString(err), file, line, func);
-}
+    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 ___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 ___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 ___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 ___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 ___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 ___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 ___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);
-}
+    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__ */
\ No newline at end of file

modules/gpu/test/test_video.cpp

@@ -225,7 +225,7 @@ TEST_P(InterpolateFrames, Regression)
 
 #ifndef DUMP
 
-    EXPECT_MAT_NEAR(newFrame_gold, newFrame, 1e-4);
+    EXPECT_MAT_NEAR(newFrame_gold, newFrame, 1e-3);
 
 #else