From beb377b38cbd3ef346b596d9609e6a7a27c6128c Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 25 Oct 2012 13:27:14 +0400
Subject: [PATCH 001/155] gpu implementation of Dual TV-L1 Optical Flow

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  89 ++++++
 modules/gpu/perf/perf_video.cpp         |  50 ++++
 modules/gpu/src/cuda/tvl1flow.cu        | 344 ++++++++++++++++++++++++
 modules/gpu/src/tvl1flow.cpp            | 256 ++++++++++++++++++
 modules/gpu/test/test_video.cpp         |  39 +++
 samples/gpu/tvl1_optical_flow.cpp       | 172 ++++++++++++
 6 files changed, 950 insertions(+)
 create mode 100644 modules/gpu/src/cuda/tvl1flow.cu
 create mode 100644 modules/gpu/src/tvl1flow.cpp
 create mode 100644 samples/gpu/tvl1_optical_flow.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index ddb131788..2cbd45085 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1948,6 +1948,95 @@ private:
 };
 
 
+// Implementation of the Zach, Pock and Bischof Dual TV-L1 Optical Flow method
+//
+// see reference:
+//   [1] C. Zach, T. Pock and H. Bischof, "A Duality Based Approach for Realtime TV-L1 Optical Flow".
+//   [2] Javier Sanchez, Enric Meinhardt-Llopis and Gabriele Facciolo. "TV-L1 Optical Flow Estimation".
+class CV_EXPORTS OpticalFlowDual_TVL1_GPU
+{
+public:
+    OpticalFlowDual_TVL1_GPU();
+
+    void operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy);
+
+    void collectGarbage();
+
+    /**
+     * Time step of the numerical scheme.
+     */
+    double tau;
+
+    /**
+     * Weight parameter for the data term, attachment parameter.
+     * This is the most relevant parameter, which determines the smoothness of the output.
+     * The smaller this parameter is, the smoother the solutions we obtain.
+     * It depends on the range of motions of the images, so its value should be adapted to each image sequence.
+     */
+    double lambda;
+
+    /**
+     * Weight parameter for (u - v)^2, tightness parameter.
+     * It serves as a link between the attachment and the regularization terms.
+     * In theory, it should have a small value in order to maintain both parts in correspondence.
+     * The method is stable for a large range of values of this parameter.
+     */
+    double theta;
+
+    /**
+     * Number of scales used to create the pyramid of images.
+     */
+    int nscales;
+
+    /**
+     * Number of warpings per scale.
+     * Represents the number of times that I1(x+u0) and grad( I1(x+u0) ) are computed per scale.
+     * This is a parameter that assures the stability of the method.
+     * It also affects the running time, so it is a compromise between speed and accuracy.
+     */
+    int warps;
+
+    /**
+     * Stopping criterion threshold used in the numerical scheme, which is a trade-off between precision and running time.
+     * A small value will yield more accurate solutions at the expense of a slower convergence.
+     */
+    double epsilon;
+
+    /**
+     * Stopping criterion iterations number used in the numerical scheme.
+     */
+    int iterations;
+
+    bool useInitialFlow;
+
+private:
+    void procOneScale(const GpuMat& I0, const GpuMat& I1, GpuMat& u1, GpuMat& u2);
+
+    std::vector<GpuMat> I0s;
+    std::vector<GpuMat> I1s;
+    std::vector<GpuMat> u1s;
+    std::vector<GpuMat> u2s;
+
+    GpuMat I1x_buf;
+    GpuMat I1y_buf;
+
+    GpuMat I1w_buf;
+    GpuMat I1wx_buf;
+    GpuMat I1wy_buf;
+
+    GpuMat grad_buf;
+    GpuMat rho_c_buf;
+
+    GpuMat p11_buf;
+    GpuMat p12_buf;
+    GpuMat p21_buf;
+    GpuMat p22_buf;
+
+    GpuMat diff_buf;
+    GpuMat norm_buf;
+};
+
+
 //! Interpolate frames (images) using provided optical flow (displacement field).
 //! frame0   - frame 0 (32-bit floating point images, single channel)
 //! frame1   - frame 1 (the same type and size)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index b18cb17df..b228580fd 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -394,6 +394,56 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
     }
 }
 
+//////////////////////////////////////////////////////
+// OpticalFlowDual_TVL1
+
+PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
+    Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
+{
+    declare.time(20);
+
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_flowx;
+        cv::gpu::GpuMat d_flowy;
+
+        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+
+        d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        TEST_CYCLE()
+        {
+            d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+        }
+
+        GPU_SANITY_CHECK(d_flowx);
+        GPU_SANITY_CHECK(d_flowy);
+    }
+    else
+    {
+        cv::Mat flow;
+
+        cv::OpticalFlowDual_TVL1 alg;
+
+        alg(frame0, frame1, flow);
+
+        TEST_CYCLE()
+        {
+            alg(frame0, frame1, flow);
+        }
+
+        CPU_SANITY_CHECK(flow);
+    }
+}
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 
diff --git a/modules/gpu/src/cuda/tvl1flow.cu b/modules/gpu/src/cuda/tvl1flow.cu
new file mode 100644
index 000000000..dc07d2f2e
--- /dev/null
+++ b/modules/gpu/src/cuda/tvl1flow.cu
@@ -0,0 +1,344 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or bpied warranties, including, but not limited to, the bpied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/border_interpolate.hpp"
+#include "opencv2/gpu/device/limits.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+////////////////////////////////////////////////////////////
+// centeredGradient
+
+namespace
+{
+    __global__ void centeredGradient(const PtrStepSzf src, PtrStepf dx, PtrStepf dy)
+    {
+        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)
+            return;
+
+        dx(y, x) = 0.5f * (src(y, ::min(x + 1, src.cols - 1)) - src(y, ::max(x - 1, 0)));
+        dy(y, x) = 0.5f * (src(::min(y + 1, src.rows - 1), x) - src(::max(y - 1, 0), x));
+    }
+}
+
+namespace tvl1flow
+{
+    void centeredGradient(PtrStepSzf src, PtrStepSzf dx, PtrStepSzf dy)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+
+        ::centeredGradient<<<grid, block>>>(src, dx, dy);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+////////////////////////////////////////////////////////////
+// warpBackward
+
+namespace
+{
+    static __device__ __forceinline__ float bicubicCoeff(float x_)
+    {
+        float x = fabsf(x_);
+        if (x <= 1.0f)
+        {
+            return x * x * (1.5f * x - 2.5f) + 1.0f;
+        }
+        else if (x < 2.0f)
+        {
+            return x * (x * (-0.5f * x + 2.5f) - 4.0f) + 2.0f;
+        }
+        else
+        {
+            return 0.0f;
+        }
+    }
+
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_I1 (false, cudaFilterModePoint, cudaAddressModeClamp);
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_I1x(false, cudaFilterModePoint, cudaAddressModeClamp);
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_I1y(false, cudaFilterModePoint, cudaAddressModeClamp);
+
+    __global__ void warpBackward(const PtrStepSzf I0, const PtrStepf u1, const PtrStepf u2, PtrStepf I1w, PtrStepf I1wx, PtrStepf I1wy, PtrStepf grad, PtrStepf rho)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= I0.cols || y >= I0.rows)
+            return;
+
+        const float u1Val = u1(y, x);
+        const float u2Val = u2(y, x);
+
+        const float wx = x + u1Val;
+        const float wy = y + u2Val;
+
+        const int xmin = ::ceilf(wx - 2.0f);
+        const int xmax = ::floorf(wx + 2.0f);
+
+        const int ymin = ::ceilf(wy - 2.0f);
+        const int ymax = ::floorf(wy + 2.0f);
+
+        float sum  = 0.0f;
+        float sumx = 0.0f;
+        float sumy = 0.0f;
+        float wsum = 0.0f;
+
+        for (int cy = ymin; cy <= ymax; ++cy)
+        {
+            for (int cx = xmin; cx <= xmax; ++cx)
+            {
+                const float w = bicubicCoeff(wx - cx) * bicubicCoeff(wy - cy);
+
+                sum  += w * tex2D(tex_I1 , cx, cy);
+                sumx += w * tex2D(tex_I1x, cx, cy);
+                sumy += w * tex2D(tex_I1y, cx, cy);
+
+                wsum += w;
+            }
+        }
+
+        const float coeff = 1.0f / wsum;
+
+        const float I1wVal  = sum  * coeff;
+        const float I1wxVal = sumx * coeff;
+        const float I1wyVal = sumy * coeff;
+
+        I1w(y, x)  = I1wVal;
+        I1wx(y, x) = I1wxVal;
+        I1wy(y, x) = I1wyVal;
+
+        const float Ix2 = I1wxVal * I1wxVal;
+        const float Iy2 = I1wyVal * I1wyVal;
+
+        // store the |Grad(I1)|^2
+        grad(y, x) = Ix2 + Iy2;
+
+        // compute the constant part of the rho function
+        const float I0Val = I0(y, x);
+        rho(y, x) = I1wVal - I1wxVal * u1Val - I1wyVal * u2Val - I0Val;
+    }
+}
+
+namespace tvl1flow
+{
+    void warpBackward(PtrStepSzf I0, PtrStepSzf I1, PtrStepSzf I1x, PtrStepSzf I1y, PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf I1w, PtrStepSzf I1wx, PtrStepSzf I1wy, PtrStepSzf grad, PtrStepSzf rho)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(I0.cols, block.x), divUp(I0.rows, block.y));
+
+        bindTexture(&tex_I1 , I1);
+        bindTexture(&tex_I1x, I1x);
+        bindTexture(&tex_I1y, I1y);
+
+        ::warpBackward<<<grid, block>>>(I0, u1, u2, I1w, I1wx, I1wy, grad, rho);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+////////////////////////////////////////////////////////////
+// estimateU
+
+namespace
+{
+    __device__ float divergence(const PtrStepf& v1, const PtrStepf& v2, int y, int x)
+    {
+        if (x > 0 && y > 0)
+        {
+            const float v1x = v1(y, x) - v1(y, x - 1);
+            const float v2y = v2(y, x) - v2(y - 1, x);
+            return v1x + v2y;
+        }
+        else
+        {
+            if (y > 0)
+                return v1(y, 0) + v2(y, 0) - v2(y - 1, 0);
+            else
+            {
+                if (x > 0)
+                    return v1(0, x) - v1(0, x - 1) + v2(0, x);
+                else
+                    return v1(0, 0) + v2(0, 0);
+            }
+        }
+    }
+
+    __global__ void estimateU(const PtrStepSzf I1wx, const PtrStepf I1wy,
+                              const PtrStepf grad, const PtrStepf rho_c,
+                              const PtrStepf p11, const PtrStepf p12, const PtrStepf p21, const PtrStepf p22,
+                              PtrStepf u1, PtrStepf u2, PtrStepf error,
+                              const float l_t, const float theta)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= I1wx.cols || y >= I1wx.rows)
+            return;
+
+        const float I1wxVal = I1wx(y, x);
+        const float I1wyVal = I1wy(y, x);
+        const float gradVal = grad(y, x);
+        const float u1OldVal = u1(y, x);
+        const float u2OldVal = u2(y, x);
+
+        const float rho = rho_c(y, x) + (I1wxVal * u1OldVal + I1wyVal * u2OldVal);
+
+        // estimate the values of the variable (v1, v2) (thresholding operator TH)
+
+        float d1 = 0.0f;
+        float d2 = 0.0f;
+
+        if (rho < -l_t * gradVal)
+        {
+            d1 = l_t * I1wxVal;
+            d2 = l_t * I1wyVal;
+        }
+        else if (rho > l_t * gradVal)
+        {
+            d1 = -l_t * I1wxVal;
+            d2 = -l_t * I1wyVal;
+        }
+        else if (gradVal > numeric_limits<float>::epsilon())
+        {
+            const float fi = -rho / gradVal;
+            d1 = fi * I1wxVal;
+            d2 = fi * I1wyVal;
+        }
+
+        const float v1 = u1OldVal + d1;
+        const float v2 = u2OldVal + d2;
+
+        // compute the divergence of the dual variable (p1, p2)
+
+        const float div_p1 = divergence(p11, p12, y, x);
+        const float div_p2 = divergence(p21, p22, y, x);
+
+        // estimate the values of the optical flow (u1, u2)
+
+        const float u1NewVal = v1 + theta * div_p1;
+        const float u2NewVal = v2 + theta * div_p2;
+
+        u1(y, x) = u1NewVal;
+        u2(y, x) = u2NewVal;
+
+        const float n1 = (u1OldVal - u1NewVal) * (u1OldVal - u1NewVal);
+        const float n2 = (u2OldVal - u2NewVal) * (u2OldVal - u2NewVal);
+        error(y, x) = n1 + n2;
+    }
+}
+
+namespace tvl1flow
+{
+    void estimateU(PtrStepSzf I1wx, PtrStepSzf I1wy,
+                   PtrStepSzf grad, PtrStepSzf rho_c,
+                   PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22,
+                   PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf error,
+                   float l_t, float theta)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(I1wx.cols, block.x), divUp(I1wx.rows, block.y));
+
+        ::estimateU<<<grid, block>>>(I1wx, I1wy, grad, rho_c, p11, p12, p21, p22, u1, u2, error, l_t, theta);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+////////////////////////////////////////////////////////////
+// estimateDualVariables
+
+namespace
+{
+    __global__ void estimateDualVariables(const PtrStepSzf u1, const PtrStepf u2, PtrStepf p11, PtrStepf p12, PtrStepf p21, PtrStepf p22, const float taut)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= u1.cols || y >= u1.rows)
+            return;
+
+        const float u1x = u1(y, ::min(x + 1, u1.cols - 1)) - u1(y, x);
+        const float u1y = u1(::min(y + 1, u1.rows - 1), x) - u1(y, x);
+
+        const float u2x = u2(y, ::min(x + 1, u1.cols - 1)) - u2(y, x);
+        const float u2y = u2(::min(y + 1, u1.rows - 1), x) - u2(y, x);
+
+        const float g1 = ::hypotf(u1x, u1y);
+        const float g2 = ::hypotf(u2x, u2y);
+
+        const float ng1 = 1.0f + taut * g1;
+        const float ng2 = 1.0f + taut * g2;
+
+        p11(y, x) = (p11(y, x) + taut * u1x) / ng1;
+        p12(y, x) = (p12(y, x) + taut * u1y) / ng1;
+        p21(y, x) = (p21(y, x) + taut * u2x) / ng2;
+        p22(y, x) = (p22(y, x) + taut * u2y) / ng2;
+    }
+}
+
+namespace tvl1flow
+{
+    void estimateDualVariables(PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22, float taut)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(u1.cols, block.x), divUp(u1.rows, block.y));
+
+        ::estimateDualVariables<<<grid, block>>>(u1, u2, p11, p12, p21, p22, taut);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+#endif // !defined CUDA_DISABLER
diff --git a/modules/gpu/src/tvl1flow.cpp b/modules/gpu/src/tvl1flow.cpp
new file mode 100644
index 000000000..a598a9ecf
--- /dev/null
+++ b/modules/gpu/src/tvl1flow.cpp
@@ -0,0 +1,256 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+#if !defined HAVE_CUDA || defined(CUDA_DISABLER)
+
+cv::gpu::OpticalFlowDual_TVL1_GPU::OpticalFlowDual_TVL1_GPU() { throw_nogpu(); }
+void cv::gpu::OpticalFlowDual_TVL1_GPU::operator ()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_nogpu(); }
+void cv::gpu::OpticalFlowDual_TVL1_GPU::collectGarbage() {}
+void cv::gpu::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&) { throw_nogpu(); }
+
+#else
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+cv::gpu::OpticalFlowDual_TVL1_GPU::OpticalFlowDual_TVL1_GPU()
+{
+    tau            = 0.25;
+    lambda         = 0.15;
+    theta          = 0.3;
+    nscales        = 5;
+    warps          = 5;
+    epsilon        = 0.01;
+    iterations     = 300;
+    useInitialFlow = false;
+}
+
+void cv::gpu::OpticalFlowDual_TVL1_GPU::operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy)
+{
+    CV_Assert( I0.type() == CV_8UC1 || I0.type() == CV_32FC1 );
+    CV_Assert( I0.size() == I1.size() );
+    CV_Assert( I0.type() == I1.type() );
+    CV_Assert( !useInitialFlow || (flowx.size() == I0.size() && flowx.type() == CV_32FC1 && flowy.size() == flowx.size() && flowy.type() == flowx.type()) );
+    CV_Assert( nscales > 0 );
+
+    // allocate memory for the pyramid structure
+    I0s.resize(nscales);
+    I1s.resize(nscales);
+    u1s.resize(nscales);
+    u2s.resize(nscales);
+
+    I0.convertTo(I0s[0], CV_32F, I0.depth() == CV_8U ? 1.0 : 255.0);
+    I1.convertTo(I1s[0], CV_32F, I1.depth() == CV_8U ? 1.0 : 255.0);
+
+    if (!useInitialFlow)
+    {
+        flowx.create(I0.size(), CV_32FC1);
+        flowy.create(I0.size(), CV_32FC1);
+    }
+
+    u1s[0] = flowx;
+    u2s[0] = flowy;
+
+    I1x_buf.create(I0.size(), CV_32FC1);
+    I1y_buf.create(I0.size(), CV_32FC1);
+
+    I1w_buf.create(I0.size(), CV_32FC1);
+    I1wx_buf.create(I0.size(), CV_32FC1);
+    I1wy_buf.create(I0.size(), CV_32FC1);
+
+    grad_buf.create(I0.size(), CV_32FC1);
+    rho_c_buf.create(I0.size(), CV_32FC1);
+
+    p11_buf.create(I0.size(), CV_32FC1);
+    p12_buf.create(I0.size(), CV_32FC1);
+    p21_buf.create(I0.size(), CV_32FC1);
+    p22_buf.create(I0.size(), CV_32FC1);
+
+    diff_buf.create(I0.size(), CV_32FC1);
+
+    // create the scales
+    for (int s = 1; s < nscales; ++s)
+    {
+        gpu::pyrDown(I0s[s - 1], I0s[s]);
+        gpu::pyrDown(I1s[s - 1], I1s[s]);
+
+        if (I0s[s].cols < 16 || I0s[s].rows < 16)
+        {
+            nscales = s;
+            break;
+        }
+
+        if (useInitialFlow)
+        {
+            gpu::pyrDown(u1s[s - 1], u1s[s]);
+            gpu::pyrDown(u2s[s - 1], u2s[s]);
+
+            gpu::multiply(u1s[s], Scalar::all(0.5), u1s[s]);
+            gpu::multiply(u2s[s], Scalar::all(0.5), u2s[s]);
+        }
+    }
+
+    // pyramidal structure for computing the optical flow
+    for (int s = nscales - 1; s >= 0; --s)
+    {
+        // compute the optical flow at the current scale
+        procOneScale(I0s[s], I1s[s], u1s[s], u2s[s]);
+
+        // if this was the last scale, finish now
+        if (s == 0)
+            break;
+
+        // otherwise, upsample the optical flow
+
+        // zoom the optical flow for the next finer scale
+        gpu::resize(u1s[s], u1s[s - 1], I0s[s - 1].size());
+        gpu::resize(u2s[s], u2s[s - 1], I0s[s - 1].size());
+
+        // scale the optical flow with the appropriate zoom factor
+        gpu::multiply(u1s[s - 1], Scalar::all(2), u1s[s - 1]);
+        gpu::multiply(u2s[s - 1], Scalar::all(2), u2s[s - 1]);
+    }
+}
+
+namespace tvl1flow
+{
+    void centeredGradient(PtrStepSzf src, PtrStepSzf dx, PtrStepSzf dy);
+    void warpBackward(PtrStepSzf I0, PtrStepSzf I1, PtrStepSzf I1x, PtrStepSzf I1y, PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf I1w, PtrStepSzf I1wx, PtrStepSzf I1wy, PtrStepSzf grad, PtrStepSzf rho);
+    void estimateU(PtrStepSzf I1wx, PtrStepSzf I1wy,
+                   PtrStepSzf grad, PtrStepSzf rho_c,
+                   PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22,
+                   PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf error,
+                   float l_t, float theta);
+    void estimateDualVariables(PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22, float taut);
+}
+
+void cv::gpu::OpticalFlowDual_TVL1_GPU::procOneScale(const GpuMat& I0, const GpuMat& I1, GpuMat& u1, GpuMat& u2)
+{
+    using namespace tvl1flow;
+
+    const double scaledEpsilon = epsilon * epsilon * I0.size().area();
+
+    CV_DbgAssert( I1.size() == I0.size() );
+    CV_DbgAssert( I1.type() == I0.type() );
+    CV_DbgAssert( u1.empty() || u1.size() == I0.size() );
+    CV_DbgAssert( u2.size() == u1.size() );
+
+    if (u1.empty())
+    {
+        u1.create(I0.size(), CV_32FC1);
+        u1.setTo(Scalar::all(0));
+
+        u2.create(I0.size(), CV_32FC1);
+        u2.setTo(Scalar::all(0));
+    }
+
+    GpuMat I1x = I1x_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat I1y = I1y_buf(Rect(0, 0, I0.cols, I0.rows));
+    centeredGradient(I1, I1x, I1y);
+
+    GpuMat I1w = I1w_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat I1wx = I1wx_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat I1wy = I1wy_buf(Rect(0, 0, I0.cols, I0.rows));
+
+    GpuMat grad = grad_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat rho_c = rho_c_buf(Rect(0, 0, I0.cols, I0.rows));
+
+    GpuMat p11 = p11_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat p12 = p12_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat p21 = p21_buf(Rect(0, 0, I0.cols, I0.rows));
+    GpuMat p22 = p22_buf(Rect(0, 0, I0.cols, I0.rows));
+    p11.setTo(Scalar::all(0));
+    p12.setTo(Scalar::all(0));
+    p21.setTo(Scalar::all(0));
+    p22.setTo(Scalar::all(0));
+
+    GpuMat diff = diff_buf(Rect(0, 0, I0.cols, I0.rows));
+
+    const float l_t = static_cast<float>(lambda * theta);
+    const float taut = static_cast<float>(tau / theta);
+
+    for (int warpings = 0; warpings < warps; ++warpings)
+    {
+        warpBackward(I0, I1, I1x, I1y, u1, u2, I1w, I1wx, I1wy, grad, rho_c);
+
+        double error = numeric_limits<double>::max();
+        for (int n = 0; error > scaledEpsilon && n < iterations; ++n)
+        {
+            estimateU(I1wx, I1wy, grad, rho_c, p11, p12, p21, p22, u1, u2, diff, l_t, static_cast<float>(theta));
+
+            error = gpu::sum(diff, norm_buf)[0];
+
+            estimateDualVariables(u1, u2, p11, p12, p21, p22, taut);
+        }
+    }
+}
+
+void cv::gpu::OpticalFlowDual_TVL1_GPU::collectGarbage()
+{
+    I0s.clear();
+    I1s.clear();
+    u1s.clear();
+    u2s.clear();
+
+    I1x_buf.release();
+    I1y_buf.release();
+
+    I1w_buf.release();
+    I1wx_buf.release();
+    I1wy_buf.release();
+
+    grad_buf.release();
+    rho_c_buf.release();
+
+    p11_buf.release();
+    p12_buf.release();
+    p21_buf.release();
+    p22_buf.release();
+
+    diff_buf.release();
+    norm_buf.release();
+}
+
+#endif // !defined HAVE_CUDA || defined(CUDA_DISABLER)
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index ca9442d69..2d44af1a7 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -405,6 +405,45 @@ TEST_P(OpticalFlowNan, Regression)
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
 
+//////////////////////////////////////////////////////
+// OpticalFlowDual_TVL1
+
+PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
+{
+};
+
+TEST_P(OpticalFlowDual_TVL1, Accuracy)
+{
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    const bool useRoi = GET_PARAM(1);
+
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+
+    cv::OpticalFlowDual_TVL1 alg;
+    cv::Mat flow;
+    alg(frame0, frame1, flow);
+    cv::Mat gold[2];
+    cv::split(flow, gold);
+
+    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
+    ALL_DEVICES,
+    WHOLE_SUBMAT));
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 
diff --git a/samples/gpu/tvl1_optical_flow.cpp b/samples/gpu/tvl1_optical_flow.cpp
new file mode 100644
index 000000000..c13afc1c7
--- /dev/null
+++ b/samples/gpu/tvl1_optical_flow.cpp
@@ -0,0 +1,172 @@
+#include <iostream>
+#include <fstream>
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/gpu/gpu.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+inline bool isFlowCorrect(Point2f u)
+{
+    return !cvIsNaN(u.x) && !cvIsNaN(u.y) && fabs(u.x) < 1e9 && fabs(u.y) < 1e9;
+}
+
+static Vec3b computeColor(float fx, float fy)
+{
+    static bool first = true;
+
+    // relative lengths of color transitions:
+    // these are chosen based on perceptual similarity
+    // (e.g. one can distinguish more shades between red and yellow
+    //  than between yellow and green)
+    const int RY = 15;
+    const int YG = 6;
+    const int GC = 4;
+    const int CB = 11;
+    const int BM = 13;
+    const int MR = 6;
+    const int NCOLS = RY + YG + GC + CB + BM + MR;
+    static Vec3i colorWheel[NCOLS];
+
+    if (first)
+    {
+        int k = 0;
+
+        for (int i = 0; i < RY; ++i, ++k)
+            colorWheel[k] = Vec3i(255, 255 * i / RY, 0);
+
+        for (int i = 0; i < YG; ++i, ++k)
+            colorWheel[k] = Vec3i(255 - 255 * i / YG, 255, 0);
+
+        for (int i = 0; i < GC; ++i, ++k)
+            colorWheel[k] = Vec3i(0, 255, 255 * i / GC);
+
+        for (int i = 0; i < CB; ++i, ++k)
+            colorWheel[k] = Vec3i(0, 255 - 255 * i / CB, 255);
+
+        for (int i = 0; i < BM; ++i, ++k)
+            colorWheel[k] = Vec3i(255 * i / BM, 0, 255);
+
+        for (int i = 0; i < MR; ++i, ++k)
+            colorWheel[k] = Vec3i(255, 0, 255 - 255 * i / MR);
+
+        first = false;
+    }
+
+    const float rad = sqrt(fx * fx + fy * fy);
+    const float a = atan2(-fy, -fx) / CV_PI;
+
+    const float fk = (a + 1.0f) / 2.0f * (NCOLS - 1);
+    const int k0 = static_cast<int>(fk);
+    const int k1 = (k0 + 1) % NCOLS;
+    const float f = fk - k0;
+
+    Vec3b pix;
+
+    for (int b = 0; b < 3; b++)
+    {
+        const float col0 = colorWheel[k0][b] / 255.0;
+        const float col1 = colorWheel[k1][b] / 255.0;
+
+        float col = (1 - f) * col0 + f * col1;
+
+        if (rad <= 1)
+            col = 1 - rad * (1 - col); // increase saturation with radius
+        else
+            col *= .75; // out of range
+
+        pix[2 - b] = static_cast<int>(255.0 * col);
+    }
+
+    return pix;
+}
+
+static void drawOpticalFlow(const Mat_<float>& flowx, const Mat_<float>& flowy, Mat& dst, float maxmotion = -1)
+{
+    dst.create(flowx.size(), CV_8UC3);
+    dst.setTo(Scalar::all(0));
+
+    // determine motion range:
+    float maxrad = maxmotion;
+
+    if (maxmotion <= 0)
+    {
+        maxrad = 1;
+        for (int y = 0; y < flowx.rows; ++y)
+        {
+            for (int x = 0; x < flowx.cols; ++x)
+            {
+                Point2f u(flowx(y, x), flowy(y, x));
+
+                if (!isFlowCorrect(u))
+                    continue;
+
+                maxrad = max(maxrad, sqrt(u.x * u.x + u.y * u.y));
+            }
+        }
+    }
+
+    for (int y = 0; y < flowx.rows; ++y)
+    {
+        for (int x = 0; x < flowx.cols; ++x)
+        {
+            Point2f u(flowx(y, x), flowy(y, x));
+
+            if (isFlowCorrect(u))
+                dst.at<Vec3b>(y, x) = computeColor(u.x / maxrad, u.y / maxrad);
+        }
+    }
+}
+
+int main(int argc, const char* argv[])
+{
+    if (argc < 3)
+    {
+        cerr << "Usage : " << argv[0] << "<frame0> <frame1>" << endl;
+        return -1;
+    }
+
+    Mat frame0 = imread(argv[1], IMREAD_GRAYSCALE);
+    Mat frame1 = imread(argv[2], IMREAD_GRAYSCALE);
+
+    if (frame0.empty())
+    {
+        cerr << "Can't open image ["  << argv[1] << "]" << endl;
+        return -1;
+    }
+    if (frame1.empty())
+    {
+        cerr << "Can't open image ["  << argv[2] << "]" << endl;
+        return -1;
+    }
+
+    if (frame1.size() != frame0.size())
+    {
+        cerr << "Images should be of equal sizes" << endl;
+        return -1;
+    }
+
+    GpuMat d_frame0(frame0);
+    GpuMat d_frame1(frame1);
+
+    GpuMat d_flowx, d_flowy;
+    OpticalFlowDual_TVL1_GPU tvl1;
+
+    const double start = getTickCount();
+    tvl1(d_frame0, d_frame1, d_flowx, d_flowy);
+    const double timeSec = (getTickCount() - start) / getTickFrequency();
+    cout << "Time : " << timeSec << " sec" << endl;
+
+    Mat flowx(d_flowx);
+    Mat flowy(d_flowy);
+    Mat out;
+    drawOpticalFlow(flowx, flowy, out);
+
+    imshow("Flow", out);
+    waitKey();
+
+    return 0;
+}

From bff818afbd3feca29b8b4ef10b5be68aa5ada7f1 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 8 Nov 2012 15:49:56 +0400
Subject: [PATCH 002/155] fixed static build of gpu module with ffmpeg:

multiple definition of cap_ffmpeg_impl.hpp functions in gpu and highgui
---
 modules/gpu/src/ffmpeg_video_source.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/ffmpeg_video_source.cpp b/modules/gpu/src/ffmpeg_video_source.cpp
index a0f420507..7538de601 100644
--- a/modules/gpu/src/ffmpeg_video_source.cpp
+++ b/modules/gpu/src/ffmpeg_video_source.cpp
@@ -44,7 +44,7 @@
 
 #if defined(HAVE_CUDA) && !defined(__APPLE__)
 
-#ifdef HAVE_FFMPEG
+#if defined(HAVE_FFMPEG) && defined(BUILD_SHARED_LIBS)
     #include "cap_ffmpeg_impl.hpp"
 #else
     #include "cap_ffmpeg_api.hpp"

From d65b3e06170e906a68d5f370501facf5ffaacd30 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 5 Sep 2012 10:48:07 +0400
Subject: [PATCH 003/155] fix warning in CUDA samples

---
 modules/gpu/src/cuda/bf_knnmatch.cu          |  2 +-
 modules/gpu/src/nvidia/core/NCV.hpp          |  2 +-
 samples/gpu/cascadeclassifier_nvidia_api.cpp |  8 ++++----
 samples/gpu/opticalflow_nvidia_api.cpp       | 16 ++++++++--------
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/modules/gpu/src/cuda/bf_knnmatch.cu b/modules/gpu/src/cuda/bf_knnmatch.cu
index 6a778735b..b31f25ca8 100644
--- a/modules/gpu/src/cuda/bf_knnmatch.cu
+++ b/modules/gpu/src/cuda/bf_knnmatch.cu
@@ -1034,7 +1034,7 @@ namespace cv { namespace gpu { namespace device
                 cudaSafeCall( cudaDeviceSynchronize() );
         }
 
-        void findKnnMatchDispatcher(int k, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream)
+        void findKnnMatchDispatcher(int k, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int /*cc*/, cudaStream_t stream)
         {
             findKnnMatch<256>(k, static_cast<PtrStepSzi>(trainIdx), static_cast<PtrStepSzf>(distance), allDist, stream);
         }
diff --git a/modules/gpu/src/nvidia/core/NCV.hpp b/modules/gpu/src/nvidia/core/NCV.hpp
index ddac47c92..26b1d4ef1 100644
--- a/modules/gpu/src/nvidia/core/NCV.hpp
+++ b/modules/gpu/src/nvidia/core/NCV.hpp
@@ -288,7 +288,7 @@ NCV_EXPORTS void ncvSetDebugOutputHandler(NCVDebugOutputHandler* func);
     do \
     { \
         cudaError_t res = cudacall; \
-        ncvAssertPrintReturn(cudaSuccess==res, "cudaError_t=" << res, errCode); \
+        ncvAssertPrintReturn(cudaSuccess==res, "cudaError_t=" << (int)res, errCode); \
     } while (0)
 
 
diff --git a/samples/gpu/cascadeclassifier_nvidia_api.cpp b/samples/gpu/cascadeclassifier_nvidia_api.cpp
index da98643af..99c95ab97 100644
--- a/samples/gpu/cascadeclassifier_nvidia_api.cpp
+++ b/samples/gpu/cascadeclassifier_nvidia_api.cpp
@@ -30,7 +30,7 @@ const Size2i preferredVideoFrameSize(640, 480);
 const string wndTitle = "NVIDIA Computer Vision :: Haar Classifiers Cascade";
 
 
-void matPrint(Mat &img, int lineOffsY, Scalar fontColor, const string &ss)
+static void matPrint(Mat &img, int lineOffsY, Scalar fontColor, const string &ss)
 {
     int fontFace = FONT_HERSHEY_DUPLEX;
     double fontScale = 0.8;
@@ -45,7 +45,7 @@ void matPrint(Mat &img, int lineOffsY, Scalar fontColor, const string &ss)
 }
 
 
-void displayState(Mat &canvas, bool bHelp, bool bGpu, bool bLargestFace, bool bFilter, double fps)
+static void displayState(Mat &canvas, bool bHelp, bool bGpu, bool bLargestFace, bool bFilter, double fps)
 {
     Scalar fontColorRed = CV_RGB(255,0,0);
     Scalar fontColorNV  = CV_RGB(118,185,0);
@@ -74,7 +74,7 @@ void displayState(Mat &canvas, bool bHelp, bool bGpu, bool bLargestFace, bool bF
 }
 
 
-NCVStatus process(Mat *srcdst,
+static NCVStatus process(Mat *srcdst,
                   Ncv32u width, Ncv32u height,
                   NcvBool bFilterRects, NcvBool bLargestFace,
                   HaarClassifierCascadeDescriptor &haar,
@@ -281,7 +281,7 @@ int main(int argc, const char** argv)
     //==============================================================================
 
     namedWindow(wndTitle, 1);
-    Mat gray, frameDisp;
+    Mat frameDisp;
 
     do
     {
diff --git a/samples/gpu/opticalflow_nvidia_api.cpp b/samples/gpu/opticalflow_nvidia_api.cpp
index 8a149d740..05a37ef69 100644
--- a/samples/gpu/opticalflow_nvidia_api.cpp
+++ b/samples/gpu/opticalflow_nvidia_api.cpp
@@ -59,7 +59,7 @@ public:
 class RgbToR
 {
 public:
-    float operator ()(unsigned char b, unsigned char g, unsigned char r)
+    float operator ()(unsigned char /*b*/, unsigned char /*g*/, unsigned char r)
     {
         return static_cast<float>(r)/255.0f;
     }
@@ -69,7 +69,7 @@ public:
 class RgbToG
 {
 public:
-    float operator ()(unsigned char b, unsigned char g, unsigned char r)
+    float operator ()(unsigned char /*b*/, unsigned char g, unsigned char /*r*/)
     {
         return static_cast<float>(g)/255.0f;
     }
@@ -78,7 +78,7 @@ public:
 class RgbToB
 {
 public:
-    float operator ()(unsigned char b, unsigned char g, unsigned char r)
+    float operator ()(unsigned char b, unsigned char /*g*/, unsigned char /*r*/)
     {
         return static_cast<float>(b)/255.0f;
     }
@@ -135,7 +135,7 @@ NCVStatus CopyData(const IplImage *image, const NCVMatrixAlloc<Ncv32f> &dst)
     return NCV_SUCCESS;
 }
 
-NCVStatus LoadImages (const char *frame0Name,
+static NCVStatus LoadImages (const char *frame0Name,
                       const char *frame1Name,
                       int &width,
                       int &height,
@@ -186,7 +186,7 @@ inline T MapValue (T x, T a, T b, T c, T d)
     return c + (d - c) * (x - a) / (b - a);
 }
 
-NCVStatus ShowFlow (NCVMatrixAlloc<Ncv32f> &u, NCVMatrixAlloc<Ncv32f> &v, const char *name)
+static NCVStatus ShowFlow (NCVMatrixAlloc<Ncv32f> &u, NCVMatrixAlloc<Ncv32f> &v, const char *name)
 {
     IplImage *flowField;
 
@@ -246,7 +246,7 @@ NCVStatus ShowFlow (NCVMatrixAlloc<Ncv32f> &u, NCVMatrixAlloc<Ncv32f> &v, const
     return NCV_SUCCESS;
 }
 
-IplImage *CreateImage (NCVMatrixAlloc<Ncv32f> &h_r, NCVMatrixAlloc<Ncv32f> &h_g, NCVMatrixAlloc<Ncv32f> &h_b)
+static IplImage *CreateImage (NCVMatrixAlloc<Ncv32f> &h_r, NCVMatrixAlloc<Ncv32f> &h_g, NCVMatrixAlloc<Ncv32f> &h_b)
 {
     CvSize imageSize = cvSize (h_r.width (), h_r.height ());
     IplImage *image  = cvCreateImage (imageSize, IPL_DEPTH_8U, 4);
@@ -270,7 +270,7 @@ IplImage *CreateImage (NCVMatrixAlloc<Ncv32f> &h_r, NCVMatrixAlloc<Ncv32f> &h_g,
     return image;
 }
 
-void PrintHelp ()
+static void PrintHelp ()
 {
     std::cout << "Usage help:\n";
     std::cout << std::setiosflags(std::ios::left);
@@ -286,7 +286,7 @@ void PrintHelp ()
     std::cout << "\t" << std::setw(15) << PARAM_HELP << " - display this help message\n";
 }
 
-int ProcessCommandLine(int argc, char **argv,
+static int ProcessCommandLine(int argc, char **argv,
                        Ncv32f &timeStep,
                        char *&frame0Name,
                        char *&frame1Name,

From dd9c53497bb8c32d411d8b5e784b249ad9d13364 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 03:28:45 +0400
Subject: [PATCH 004/155] GPU interface for soft cascade

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  43 ++++++++++
 modules/gpu/src/softcascade.cpp         | 100 ++++++++++++++++++++++++
 2 files changed, 143 insertions(+)
 create mode 100644 modules/gpu/src/softcascade.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index ddb131788..4a2d88aa0 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1532,6 +1532,49 @@ public:
     int detectMultiScale(const GpuMat& image, GpuMat& objectsBuf, Size maxObjectSize, Size minSize = Size(), double scaleFactor = 1.1, int minNeighbors = 4);
 };
 
+// ======================== GPU version for soft cascade ===================== //
+
+class CV_EXPORTS SoftCascade
+{
+public:
+    //! An empty cascade will be created.
+    SoftCascade();
+
+    //! Cascade will be created from file for scales from minScale to maxScale.
+    //! Param filename is a path to xml-serialized cascade.
+    //! Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
+    //! Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
+    SoftCascade( const string& filename, const float minScale = 0.4f, const float maxScale = 5.f);
+
+    //! cascade will be loaded from file "filename". The previous cascade will be destroyed.
+    //! Param filename is a path to xml-serialized cascade.
+    //! Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
+    //! Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
+    bool load( const string& filename, const float minScale = 0.4f, const float maxScale = 5.f);
+
+    virtual ~SoftCascade();
+
+    //! return vector of bounding boxes. Each box contains one detected object
+    virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
+    int rejectfactor = 1, Stream stream = Stream::Null()); // ToDo store objects in GPU mem
+
+protected:
+    enum { BOOST = 0 };
+    enum
+    {
+        FRAME_WIDTH        = 640,
+        FRAME_HEIGHT       = 480,
+        TOTAL_SCALES       = 55,
+        CLASSIFIERS        = 5,
+        ORIG_OBJECT_WIDTH  = 64,
+        ORIG_OBJECT_HEIGHT = 128
+    };
+
+private:
+    struct Filds;
+    Filds* filds;
+};
+
 ////////////////////////////////// SURF //////////////////////////////////////////
 
 class CV_EXPORTS SURF_GPU
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
new file mode 100644
index 000000000..509e3f501
--- /dev/null
+++ b/modules/gpu/src/softcascade.cpp
@@ -0,0 +1,100 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <precomp.hpp>
+
+#if !defined (HAVE_CUDA)
+
+cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
+
+cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
+
+cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
+
+bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); }
+
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, Stream) { throw_nogpu(); }
+
+#else
+
+struct cv::gpu::SoftCascade::Filds
+{
+    bool fill(const FileNode &root, const float mins, const float maxs){return true;}
+    void calcLevels(int frameW, int frameH, int scales) {}
+};
+
+cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
+
+cv::gpu::SoftCascade::SoftCascade( const string& filename, const float minScale, const float maxScale) : filds(0)
+{
+    load(filename, minScale, maxScale);
+}
+
+cv::gpu::SoftCascade::~SoftCascade()
+{
+    delete filds;
+}
+
+bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, const float maxScale)
+{
+    if (filds)
+        delete filds;
+    filds = 0;
+
+    cv::FileStorage fs(filename, FileStorage::READ);
+    if (!fs.isOpened()) return false;
+
+    filds = new Filds;
+    Filds& flds = *filds;
+    if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
+    flds.calcLevels(FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
+
+    return true;
+}
+
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& /*image*/, const GpuMat& /*rois*/,
+                                GpuMat& /*objects*/, const int /*rejectfactor*/, Stream /*stream*/)
+{
+    // empty
+}
+
+#endif

From 267d140bfeb43b1c47734e554c37c0b1db81787f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 16:22:10 +0400
Subject: [PATCH 005/155] soft cascade: gpu representation

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   9 +-
 modules/gpu/src/cuda/isf-sc.cu          |  43 +++++
 modules/gpu/src/icf.hpp                 | 118 ++++++++++++
 modules/gpu/src/softcascade.cpp         | 236 +++++++++++++++++++++++-
 modules/gpu/test/test_softcascade.cpp   |  73 ++++++++
 5 files changed, 473 insertions(+), 6 deletions(-)
 create mode 100644 modules/gpu/src/cuda/isf-sc.cu
 create mode 100644 modules/gpu/src/icf.hpp
 create mode 100644 modules/gpu/test/test_softcascade.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 4a2d88aa0..61f6006c5 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1554,9 +1554,14 @@ public:
 
     virtual ~SoftCascade();
 
-    //! return vector of bounding boxes. Each box contains one detected object
+    //! detect specific objects on in the input frame for all scales computed flom minScale and maxscale values
+    //! Param image is input frame for detector. Cascade will be applied to it.
+    //! Param rois is a mask
+    //! Param objects 4-channel matrix thet contain detected rectangles
+    //! Param rejectfactor used for final object box computing
+    //! Param stream
     virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor = 1, Stream stream = Stream::Null()); // ToDo store objects in GPU mem
+    int rejectfactor = 1, Stream stream = Stream::Null());
 
 protected:
     enum { BOOST = 0 };
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
new file mode 100644
index 000000000..f36f86f96
--- /dev/null
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -0,0 +1,43 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <icf.hpp>
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
new file mode 100644
index 000000000..110890232
--- /dev/null
+++ b/modules/gpu/src/icf.hpp
@@ -0,0 +1,118 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_ICF_HPP__
+#define __OPENCV_ICF_HPP__
+
+#if defined __CUDACC__
+# define __hd__ __host__ __device__ __forceinline__
+#else
+# define __hd__
+#endif
+
+
+namespace icf {
+
+    struct Cascade
+    {
+
+    };
+
+    struct ChannelStorage
+    {
+
+    };
+
+    struct __align__(16) Octave
+    {
+        ushort index;
+        ushort stages;
+        ushort shrinkage;
+        ushort2 size;
+        float scale;
+
+        Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+        : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+    };
+
+    struct __align__(8) Node
+    {
+        int feature;
+        float threshold;
+
+        Node(const int f, const float t) : feature(f), threshold(t) {}
+    };
+
+    struct __align__(8) Feature
+    {
+        int channel;
+        uchar4 rect;
+
+        Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+    };
+
+    struct __align__(8) Level //is actually 24 bytes
+    {
+        int octave;
+
+        // float origScale; //not actually used
+        float relScale;
+        float shrScale;   // used for marking detection
+        float scaling[2]; // calculated according to Dollal paper
+
+        // for 640x480 we can not get overflow
+        uchar2 workRect;
+        uchar2 objSize;
+
+        Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+        :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+        {
+            workRect.x = round(w / (float)oct.shrinkage);
+            workRect.y = round(h / (float)oct.shrinkage);
+
+            objSize.x  = round(oct.size.x * relScale);
+            objSize.y  = round(oct.size.y * relScale);
+        }
+    };
+}
+
+#endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 509e3f501..04b68539c 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -56,12 +56,242 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat
 
 #else
 
+#include <icf.hpp>
+
 struct cv::gpu::SoftCascade::Filds
 {
-    bool fill(const FileNode &root, const float mins, const float maxs){return true;}
-    void calcLevels(int frameW, int frameH, int scales) {}
+    // scales range
+    float minScale;
+    float maxScale;
+
+    int origObjWidth;
+    int origObjHeight;
+
+    GpuMat octaves;
+    GpuMat stages;
+    GpuMat nodes;
+    GpuMat leaves;
+    GpuMat features;
+
+    std::vector<float> scales;
+
+    icf::Cascade cascade;
+
+    bool fill(const FileNode &root, const float mins, const float maxs);
+
+private:
+    void calcLevels(const std::vector<icf::Octave>& octs,
+                                                    int frameW, int frameH, int nscales);
+
+    typedef std::vector<icf::Octave>::const_iterator  octIt_t;
+    int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor)
+    {
+        float minAbsLog = FLT_MAX;
+        int res =  0;
+        for (int oct = 0; oct < (int)octs.size(); ++oct)
+        {
+            const icf::Octave& octave =octs[oct];
+            float logOctave = ::log(octave.scale);
+            float logAbsScale = ::fabs(logFactor - logOctave);
+
+            if(logAbsScale < minAbsLog)
+            {
+                res = oct;
+                minAbsLog = logAbsScale;
+            }
+        }
+        return res;
+    }
 };
 
+inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
+{
+    minScale = mins;
+    maxScale = maxs;
+
+    // cascade properties
+    static const char *const SC_STAGE_TYPE          = "stageType";
+    static const char *const SC_BOOST               = "BOOST";
+
+    static const char *const SC_FEATURE_TYPE        = "featureType";
+    static const char *const SC_ICF                 = "ICF";
+
+    static const char *const SC_ORIG_W              = "width";
+    static const char *const SC_ORIG_H              = "height";
+
+    static const char *const SC_OCTAVES             = "octaves";
+    static const char *const SC_STAGES              = "stages";
+    static const char *const SC_FEATURES            = "features";
+
+    static const char *const SC_WEEK                = "weakClassifiers";
+    static const char *const SC_INTERNAL            = "internalNodes";
+    static const char *const SC_LEAF                = "leafValues";
+
+    static const char *const SC_OCT_SCALE           = "scale";
+    static const char *const SC_OCT_STAGES          = "stageNum";
+    static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
+
+    static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
+
+    static const char * const SC_F_CHANNEL          = "channel";
+    static const char * const SC_F_RECT             = "rect";
+
+    // only Ada Boost supported
+    std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
+    CV_Assert(stageTypeStr == SC_BOOST);
+
+    // only HOG-like integral channel features cupported
+    string featureTypeStr = (string)root[SC_FEATURE_TYPE];
+    CV_Assert(featureTypeStr == SC_ICF);
+
+    origObjWidth = (int)root[SC_ORIG_W];
+    CV_Assert(origObjWidth == SoftCascade::ORIG_OBJECT_WIDTH);
+
+    origObjHeight = (int)root[SC_ORIG_H];
+    CV_Assert(origObjHeight == SoftCascade::ORIG_OBJECT_HEIGHT);
+
+    FileNode fn = root[SC_OCTAVES];
+        if (fn.empty()) return false;
+
+    std::vector<icf::Octave>  voctaves;
+    std::vector<float>        vstages;
+    std::vector<icf::Node>    vnodes;
+    std::vector<float>        vleaves;
+    std::vector<icf::Feature> vfeatures;
+    scales.clear();
+
+    // std::vector<Level> levels;
+
+    FileNodeIterator it = fn.begin(), it_end = fn.end();
+    int feature_offset = 0;
+    ushort octIndex = 0;
+
+    for (; it != it_end; ++it)
+    {
+        FileNode fns = *it;
+        float scale = (float)fns[SC_OCT_SCALE];
+        scales.push_back(scale);
+        ushort nstages = saturate_cast<ushort>((int)fn[SC_OCT_STAGES]);
+        ushort2 size;
+        size.x = cvRound(SoftCascade::ORIG_OBJECT_WIDTH * scale);
+        size.y = cvRound(SoftCascade::ORIG_OBJECT_HEIGHT * scale);
+        ushort shrinkage = saturate_cast<ushort>((int)fn[SC_OCT_SHRINKAGE]);
+
+        icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
+        CV_Assert(octave.stages > 0);
+        voctaves.push_back(octave);
+
+        FileNode ffs = fns[SC_FEATURES];
+        if (ffs.empty()) return false;
+
+        fns = fns[SC_STAGES];
+        if (fn.empty()) return false;
+
+        // for each stage (~ decision tree with H = 2)
+        FileNodeIterator st = fns.begin(), st_end = fns.end();
+        for (; st != st_end; ++st )
+        {
+            fns = *st;
+            vstages.push_back((float)fn[SC_STAGE_THRESHOLD]);
+
+            fns = fns[SC_WEEK];
+            FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
+            for (; ftr != ft_end; ++ftr)
+            {
+                fns = (*ftr)[SC_INTERNAL];
+                FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
+                for (; inIt != inIt_end;)
+                {
+                    int feature = (int)(*(inIt +=2)++) + feature_offset;
+                    vnodes.push_back(icf::Node(feature, (float)(*(inIt++))));
+                }
+
+                fns = (*ftr)[SC_LEAF];
+                inIt = fns.begin(), inIt_end = fns.end();
+                for (; inIt != inIt_end; ++inIt)
+                    vleaves.push_back((float)(*inIt));
+            }
+        }
+
+        st = ffs.begin(), st_end = ffs.end();
+        for (; st != st_end; ++st )
+        {
+            cv::FileNode rn = (*st)[SC_F_RECT];
+            cv::FileNodeIterator r_it = rn.begin();
+            uchar4 rect;
+            rect.x = saturate_cast<uchar>((int)*(r_it++));
+            rect.y = saturate_cast<uchar>((int)*(r_it++));
+            rect.z = saturate_cast<uchar>((int)*(r_it++));
+            rect.w = saturate_cast<uchar>((int)*(r_it++));
+            vfeatures.push_back(icf::Feature((int)(*st)[SC_F_CHANNEL], rect));
+        }
+
+        feature_offset += octave.stages * 3;
+        ++octIndex;
+    }
+
+    // upload in gpu memory
+    octaves.upload(cv::Mat(1, voctaves.size() * sizeof(icf::Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
+    CV_Assert(!octaves.empty());
+
+    stages.upload(cv::Mat(vstages).reshape(1,1));
+    CV_Assert(!stages.empty());
+
+    nodes.upload(cv::Mat(1, vnodes.size() * sizeof(icf::Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
+    CV_Assert(!nodes.empty());
+
+    leaves.upload(cv::Mat(vleaves).reshape(1,1));
+    CV_Assert(!leaves.empty());
+
+    features.upload(cv::Mat(1, vfeatures.size() * sizeof(icf::Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
+    CV_Assert(!features.empty());
+
+    // compute levels
+    calcLevels(voctaves, (int)SoftCascade::FRAME_WIDTH, (int)SoftCascade::FRAME_HEIGHT, (int)SoftCascade::TOTAL_SCALES);
+
+    return true;
+}
+
+inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octave>& octs,
+                                                    int frameW, int frameH, int nscales)
+{
+    CV_Assert(nscales > 1);
+
+    std::vector<icf::Level> levels;
+    float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
+
+    float scale = minScale;
+    for (int sc = 0; sc < nscales; ++sc)
+    {
+        int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
+        int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
+
+        float logScale = ::log(scale);
+        int fit = fitOctave(octs, logScale);
+
+        icf::Level level(fit, octs[fit], scale, width, height);
+
+        if (!width || !height)
+            break;
+        else
+            levels.push_back(level);
+
+        if (::fabs(scale - maxScale) < FLT_EPSILON) break;
+        scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
+
+        // std::cout << "level " << sc << " scale "
+        //           << levels[sc].origScale
+        //           << " octeve "
+        //           << levels[sc].octave->scale
+        //           << " "
+        //           << levels[sc].relScale
+        //           << " " << levels[sc].shrScale
+        //           << " [" << levels[sc].objSize.width
+        //           << " " << levels[sc].objSize.height << "] ["
+        // << levels[sc].workRect.width << " " << levels[sc].workRect.height << "]" << std::endl;
+    }
+}
+
 cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
 
 cv::gpu::SoftCascade::SoftCascade( const string& filename, const float minScale, const float maxScale) : filds(0)
@@ -86,8 +316,6 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     filds = new Filds;
     Filds& flds = *filds;
     if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
-    flds.calcLevels(FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
-
     return true;
 }
 
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
new file mode 100644
index 000000000..821a2b140
--- /dev/null
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -0,0 +1,73 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <test_precomp.hpp>
+
+#ifdef HAVE_CUDA
+
+using cv::gpu::GpuMat;
+
+TEST(SoftCascade, readCascade)
+{
+    std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/icf-template.xml";
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(xml));
+
+}
+
+TEST(SoftCascade, detect)
+{
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(xml));
+
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + "cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
+    GpuMat colored(coloredCpu), objectBoxes, rois;
+
+    // ASSERT_NO_THROW(
+    // {
+        cascade.detectMultiScale(colored, rois, objectBoxes);
+    // });
+}
+
+#endif
\ No newline at end of file

From 2b7ce8b16031124d4ebd261fd5b70e5fbc5f6d5a Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 16:44:38 +0400
Subject: [PATCH 006/155] precompute feature response for scaling factor

---
 modules/gpu/src/softcascade.cpp | 36 +++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 04b68539c..18306e04d 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -252,6 +252,40 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     return true;
 }
 
+namespace {
+    struct CascadeIntrinsics
+    {
+        static const float lambda = 1.099f, a = 0.89f;
+
+        static float getFor(int channel, float scaling)
+        {
+            CV_Assert(channel < 10);
+
+            if (fabs(scaling - 1.f) < FLT_EPSILON)
+                return 1.f;
+
+            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
+            static const float A[2][2] =
+            {   //channel <= 6, otherwise
+                {        0.89f, 1.f}, // down
+                {        1.00f, 1.f}  // up
+            };
+
+            static const float B[2][2] =
+            {   //channel <= 6,  otherwise
+                { 1.099f / log(2), 2.f}, // down
+                {             0.f, 2.f}  // up
+            };
+
+            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
+            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
+
+            printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
+            return a * pow(scaling, b);
+        }
+    };
+}
+
 inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octave>& octs,
                                                     int frameW, int frameH, int nscales)
 {
@@ -270,6 +304,8 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octav
         int fit = fitOctave(octs, logScale);
 
         icf::Level level(fit, octs[fit], scale, width, height);
+        level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
+        level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
 
         if (!width || !height)
             break;

From 1ab7af69956491e5965a0429093c2296b91b7428 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 18:35:48 +0400
Subject: [PATCH 007/155] GPU soft cascade: buffers preallocation

---
 modules/gpu/include/opencv2/gpu/gpu.hpp | 12 -----
 modules/gpu/src/icf.hpp                 | 16 +++++-
 modules/gpu/src/softcascade.cpp         | 68 +++++++++++++++++++++----
 3 files changed, 72 insertions(+), 24 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 61f6006c5..5008e1027 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1563,18 +1563,6 @@ public:
     virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
     int rejectfactor = 1, Stream stream = Stream::Null());
 
-protected:
-    enum { BOOST = 0 };
-    enum
-    {
-        FRAME_WIDTH        = 640,
-        FRAME_HEIGHT       = 480,
-        TOTAL_SCALES       = 55,
-        CLASSIFIERS        = 5,
-        ORIG_OBJECT_WIDTH  = 64,
-        ORIG_OBJECT_HEIGHT = 128
-    };
-
 private:
     struct Filds;
     Filds* filds;
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 110890232..49919a79c 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -40,6 +40,8 @@
 //
 //M*/
 
+#include <opencv2/gpu/device/common.hpp>
+
 #ifndef __OPENCV_ICF_HPP__
 #define __OPENCV_ICF_HPP__
 
@@ -54,12 +56,24 @@ namespace icf {
 
     struct Cascade
     {
+        Cascade() {}
+        Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
+            const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
+        : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+
+        cv::gpu::PtrStepSzb octaves;
+        cv::gpu::PtrStepSzf stages;
+        cv::gpu::PtrStepSzb nodes;
+        cv::gpu::PtrStepSzf leaves;
+        cv::gpu::PtrStepSzb features;
+
+        cv::gpu::PtrStepSzb levels;
 
     };
 
     struct ChannelStorage
     {
-
+        ChannelStorage(const cv::gpu::PtrStepSzb& /*f*/, const int /*shrinkage*/) {}
     };
 
     struct __align__(16) Octave
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 18306e04d..8ef1da457 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -72,19 +72,41 @@ struct cv::gpu::SoftCascade::Filds
     GpuMat nodes;
     GpuMat leaves;
     GpuMat features;
+    GpuMat levels;
+
+    // preallocated buffer 640x480x10
+    GpuMat dmem;
+    // 160x120x10
+    GpuMat shrunk;
+    // 161x121x10
+    GpuMat hogluv;
 
     std::vector<float> scales;
 
     icf::Cascade cascade;
 
     bool fill(const FileNode &root, const float mins, const float maxs);
+    void detect(const icf::ChannelStorage& /*channels*/) const {}
+
+    enum { BOOST = 0 };
+    enum
+    {
+        FRAME_WIDTH        = 640,
+        FRAME_HEIGHT       = 480,
+        TOTAL_SCALES       = 55,
+        CLASSIFIERS        = 5,
+        ORIG_OBJECT_WIDTH  = 64,
+        ORIG_OBJECT_HEIGHT = 128,
+        HOG_BINS           = 6,
+        HOG_LUV_BINS       = 10
+    };
 
 private:
     void calcLevels(const std::vector<icf::Octave>& octs,
                                                     int frameW, int frameH, int nscales);
 
     typedef std::vector<icf::Octave>::const_iterator  octIt_t;
-    int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor)
+    int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor) const
     {
         float minAbsLog = FLT_MAX;
         int res =  0;
@@ -145,10 +167,10 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     CV_Assert(featureTypeStr == SC_ICF);
 
     origObjWidth = (int)root[SC_ORIG_W];
-    CV_Assert(origObjWidth == SoftCascade::ORIG_OBJECT_WIDTH);
+    CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
 
     origObjHeight = (int)root[SC_ORIG_H];
-    CV_Assert(origObjHeight == SoftCascade::ORIG_OBJECT_HEIGHT);
+    CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
 
     FileNode fn = root[SC_OCTAVES];
         if (fn.empty()) return false;
@@ -165,6 +187,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     FileNodeIterator it = fn.begin(), it_end = fn.end();
     int feature_offset = 0;
     ushort octIndex = 0;
+    ushort shrinkage = 1;
 
     for (; it != it_end; ++it)
     {
@@ -173,9 +196,9 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
         scales.push_back(scale);
         ushort nstages = saturate_cast<ushort>((int)fn[SC_OCT_STAGES]);
         ushort2 size;
-        size.x = cvRound(SoftCascade::ORIG_OBJECT_WIDTH * scale);
-        size.y = cvRound(SoftCascade::ORIG_OBJECT_HEIGHT * scale);
-        ushort shrinkage = saturate_cast<ushort>((int)fn[SC_OCT_SHRINKAGE]);
+        size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
+        size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
+        shrinkage = saturate_cast<ushort>((int)fn[SC_OCT_SHRINKAGE]);
 
         icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
         CV_Assert(octave.stages > 0);
@@ -247,7 +270,16 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     CV_Assert(!features.empty());
 
     // compute levels
-    calcLevels(voctaves, (int)SoftCascade::FRAME_WIDTH, (int)SoftCascade::FRAME_HEIGHT, (int)SoftCascade::TOTAL_SCALES);
+    calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
+    CV_Assert(!levels.empty());
+
+    // init Cascade
+    cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
+
+    // allocate buffers
+    dmem.create(FRAME_HEIGHT * HOG_LUV_BINS, FRAME_WIDTH, CV_8UC1);
+    shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
+    hogluv.create( (FRAME_HEIGHT / shrinkage * HOG_LUV_BINS) + 1, (FRAME_WIDTH / shrinkage) + 1, CV_16UC1);
 
     return true;
 }
@@ -291,7 +323,7 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octav
 {
     CV_Assert(nscales > 1);
 
-    std::vector<icf::Level> levels;
+    std::vector<icf::Level> vlevels;
     float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
 
     float scale = minScale;
@@ -310,11 +342,13 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octav
         if (!width || !height)
             break;
         else
-            levels.push_back(level);
+            vlevels.push_back(level);
 
         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
+        levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
+
         // std::cout << "level " << sc << " scale "
         //           << levels[sc].origScale
         //           << " octeve "
@@ -355,10 +389,22 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     return true;
 }
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& /*image*/, const GpuMat& /*rois*/,
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /*rois*/,
                                 GpuMat& /*objects*/, const int /*rejectfactor*/, Stream /*stream*/)
 {
-    // empty
+    // only color images are supperted
+    CV_Assert(image.type() == CV_8UC3);
+
+    // only this window size allowed
+    CV_Assert(image.cols == 640 && image.rows == 480);
+
+
+    // ToDo: add shrincage in whole cascade.
+    const int shrincage = 4;
+    icf::ChannelStorage storage(image, shrincage);
+
+    const Filds& flds = *filds;
+    flds.detect(storage);
 }
 
 #endif

From 4aac1444ad21041b226199d6fb6dcc12d884f928 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 18:51:41 +0400
Subject: [PATCH 008/155] integral channel storage are cached as a cascade's
 field

---
 modules/gpu/src/icf.hpp         | 156 +++++++++++++++++---------------
 modules/gpu/src/softcascade.cpp |  13 ++-
 2 files changed, 91 insertions(+), 78 deletions(-)

diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 49919a79c..8cc4395c3 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -54,79 +54,93 @@
 
 namespace icf {
 
-    struct Cascade
+using cv::gpu::PtrStepSzb;
+using cv::gpu::PtrStepSzf;
+
+struct Cascade
+{
+    Cascade() {}
+    Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
+        const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
+    : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+
+    PtrStepSzb octaves;
+    PtrStepSzf stages;
+    PtrStepSzb nodes;
+    PtrStepSzf leaves;
+    PtrStepSzb features;
+
+    PtrStepSzb levels;
+
+};
+
+struct ChannelStorage
+{
+    ChannelStorage(){}
+    ChannelStorage(const cv::gpu::PtrStepSzb& buff, const cv::gpu::PtrStepSzb& shr,
+        const cv::gpu::PtrStepSzb& itg, const int s)
+    : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
+
+    void frame(const cv::gpu::PtrStepSzb& image) {}
+
+    PtrStepSzb dmem;
+    PtrStepSzb shrunk;
+    PtrStepSzb hogluv;
+
+    int shrinkage;
+};
+
+struct __align__(16) Octave
+{
+    ushort index;
+    ushort stages;
+    ushort shrinkage;
+    ushort2 size;
+    float scale;
+
+    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+};
+
+struct __align__(8) Node
+{
+    int feature;
+    float threshold;
+
+    Node(const int f, const float t) : feature(f), threshold(t) {}
+};
+
+struct __align__(8) Feature
+{
+    int channel;
+    uchar4 rect;
+
+    Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+};
+
+struct __align__(8) Level //is actually 24 bytes
+{
+    int octave;
+
+    // float origScale; //not actually used
+    float relScale;
+    float shrScale;   // used for marking detection
+    float scaling[2]; // calculated according to Dollal paper
+
+    // for 640x480 we can not get overflow
+    uchar2 workRect;
+    uchar2 objSize;
+
+    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
     {
-        Cascade() {}
-        Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
-            const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
-        : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+        workRect.x = round(w / (float)oct.shrinkage);
+        workRect.y = round(h / (float)oct.shrinkage);
 
-        cv::gpu::PtrStepSzb octaves;
-        cv::gpu::PtrStepSzf stages;
-        cv::gpu::PtrStepSzb nodes;
-        cv::gpu::PtrStepSzf leaves;
-        cv::gpu::PtrStepSzb features;
-
-        cv::gpu::PtrStepSzb levels;
-
-    };
-
-    struct ChannelStorage
-    {
-        ChannelStorage(const cv::gpu::PtrStepSzb& /*f*/, const int /*shrinkage*/) {}
-    };
-
-    struct __align__(16) Octave
-    {
-        ushort index;
-        ushort stages;
-        ushort shrinkage;
-        ushort2 size;
-        float scale;
-
-        Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
-        : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
-    };
-
-    struct __align__(8) Node
-    {
-        int feature;
-        float threshold;
-
-        Node(const int f, const float t) : feature(f), threshold(t) {}
-    };
-
-    struct __align__(8) Feature
-    {
-        int channel;
-        uchar4 rect;
-
-        Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-    };
-
-    struct __align__(8) Level //is actually 24 bytes
-    {
-        int octave;
-
-        // float origScale; //not actually used
-        float relScale;
-        float shrScale;   // used for marking detection
-        float scaling[2]; // calculated according to Dollal paper
-
-        // for 640x480 we can not get overflow
-        uchar2 workRect;
-        uchar2 objSize;
-
-        Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-        :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-        {
-            workRect.x = round(w / (float)oct.shrinkage);
-            workRect.y = round(h / (float)oct.shrinkage);
-
-            objSize.x  = round(oct.size.x * relScale);
-            objSize.y  = round(oct.size.y * relScale);
-        }
-    };
+        objSize.x  = round(oct.size.x * relScale);
+        objSize.y  = round(oct.size.y * relScale);
+    }
+};
 }
 
 #endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 8ef1da457..54f37cd17 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -84,9 +84,10 @@ struct cv::gpu::SoftCascade::Filds
     std::vector<float> scales;
 
     icf::Cascade cascade;
+    icf::ChannelStorage storage;
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(const icf::ChannelStorage& /*channels*/) const {}
+    void detect() const {}
 
     enum { BOOST = 0 };
     enum
@@ -281,6 +282,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
     hogluv.create( (FRAME_HEIGHT / shrinkage * HOG_LUV_BINS) + 1, (FRAME_WIDTH / shrinkage) + 1, CV_16UC1);
 
+    storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
     return true;
 }
 
@@ -398,13 +400,10 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /
     // only this window size allowed
     CV_Assert(image.cols == 640 && image.rows == 480);
 
+    Filds& flds = *filds;
 
-    // ToDo: add shrincage in whole cascade.
-    const int shrincage = 4;
-    icf::ChannelStorage storage(image, shrincage);
-
-    const Filds& flds = *filds;
-    flds.detect(storage);
+    flds.storage.frame(image);
+    flds.detect();
 }
 
 #endif

From a3af5ede8059b29617e400bab631c122422b6316 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 20 Sep 2012 19:35:04 +0400
Subject: [PATCH 009/155] CUDA callers

---
 modules/gpu/src/cuda/isf-sc.cu  | 13 ++++++++++++-
 modules/gpu/src/icf.hpp         |  4 +++-
 modules/gpu/src/softcascade.cpp | 17 ++++++++++-------
 3 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index f36f86f96..a6418c1d3 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -40,4 +40,15 @@
 //
 //M*/
 
-#include <icf.hpp>
\ No newline at end of file
+#include <icf.hpp>
+
+void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv) const
+{
+    // detection kernel
+}
+
+void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar4>& image)
+{
+    // color convertin kernel
+    // hog calculation kernel
+}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 8cc4395c3..7183fc0ac 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -64,6 +64,8 @@ struct Cascade
         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
 
+    void detect(const cv::gpu::PtrStepSzb& hogluv) const;
+
     PtrStepSzb octaves;
     PtrStepSzf stages;
     PtrStepSzb nodes;
@@ -81,7 +83,7 @@ struct ChannelStorage
         const cv::gpu::PtrStepSzb& itg, const int s)
     : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
 
-    void frame(const cv::gpu::PtrStepSzb& image) {}
+    void frame(const cv::gpu::PtrStepSz<uchar4>& image);
 
     PtrStepSzb dmem;
     PtrStepSzb shrunk;
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 54f37cd17..80473da95 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -74,7 +74,7 @@ struct cv::gpu::SoftCascade::Filds
     GpuMat features;
     GpuMat levels;
 
-    // preallocated buffer 640x480x10
+    // preallocated buffer 640x480x10 + 640x480
     GpuMat dmem;
     // 160x120x10
     GpuMat shrunk;
@@ -86,9 +86,6 @@ struct cv::gpu::SoftCascade::Filds
     icf::Cascade cascade;
     icf::ChannelStorage storage;
 
-    bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect() const {}
-
     enum { BOOST = 0 };
     enum
     {
@@ -102,6 +99,12 @@ struct cv::gpu::SoftCascade::Filds
         HOG_LUV_BINS       = 10
     };
 
+    bool fill(const FileNode &root, const float mins, const float maxs);
+    void detect() const
+    {
+        cascade.detect(hogluv);
+    }
+
 private:
     void calcLevels(const std::vector<icf::Octave>& octs,
                                                     int frameW, int frameH, int nscales);
@@ -278,7 +281,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
 
     // allocate buffers
-    dmem.create(FRAME_HEIGHT * HOG_LUV_BINS, FRAME_WIDTH, CV_8UC1);
+    dmem.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
     hogluv.create( (FRAME_HEIGHT / shrinkage * HOG_LUV_BINS) + 1, (FRAME_WIDTH / shrinkage) + 1, CV_16UC1);
 
@@ -395,7 +398,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /
                                 GpuMat& /*objects*/, const int /*rejectfactor*/, Stream /*stream*/)
 {
     // only color images are supperted
-    CV_Assert(image.type() == CV_8UC3);
+    CV_Assert(image.type() == CV_8UC4);
 
     // only this window size allowed
     CV_Assert(image.cols == 640 && image.rows == 480);
@@ -406,4 +409,4 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /
     flds.detect();
 }
 
-#endif
+#endif
\ No newline at end of file

From 14a0dd8c98ecff30ea17fe4ecd1a900df6f32f06 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 11:44:26 +0400
Subject: [PATCH 010/155] fix typo in cascade loading

---
 modules/gpu/src/softcascade.cpp       | 33 +++++++++++++--------------
 modules/gpu/test/test_softcascade.cpp |  7 +++---
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 80473da95..fb36efddc 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -198,11 +198,11 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
         FileNode fns = *it;
         float scale = (float)fns[SC_OCT_SCALE];
         scales.push_back(scale);
-        ushort nstages = saturate_cast<ushort>((int)fn[SC_OCT_STAGES]);
+        ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
         ushort2 size;
         size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
         size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
-        shrinkage = saturate_cast<ushort>((int)fn[SC_OCT_SHRINKAGE]);
+        shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
 
         icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
         CV_Assert(octave.stages > 0);
@@ -219,7 +219,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
         for (; st != st_end; ++st )
         {
             fns = *st;
-            vstages.push_back((float)fn[SC_STAGE_THRESHOLD]);
+            vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
 
             fns = fns[SC_WEEK];
             FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
@@ -230,7 +230,8 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
                 for (; inIt != inIt_end;)
                 {
                     int feature = (int)(*(inIt +=2)++) + feature_offset;
-                    vnodes.push_back(icf::Node(feature, (float)(*(inIt++))));
+                    float th = (float)(*(inIt++));
+                    vnodes.push_back(icf::Node(feature, th));
                 }
 
                 fns = (*ftr)[SC_LEAF];
@@ -277,7 +278,7 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
     CV_Assert(!levels.empty());
 
-    // init Cascade
+    //init Cascade
     cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
 
     // allocate buffers
@@ -317,7 +318,7 @@ namespace {
             float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
             float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
 
-            printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
+            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
             return a * pow(scaling, b);
         }
     };
@@ -352,19 +353,17 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octav
         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
-        levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
-
-        // std::cout << "level " << sc << " scale "
-        //           << levels[sc].origScale
+        // std::cout << "level " << sc
         //           << " octeve "
-        //           << levels[sc].octave->scale
-        //           << " "
-        //           << levels[sc].relScale
-        //           << " " << levels[sc].shrScale
-        //           << " [" << levels[sc].objSize.width
-        //           << " " << levels[sc].objSize.height << "] ["
-        // << levels[sc].workRect.width << " " << levels[sc].workRect.height << "]" << std::endl;
+        //           << vlevels[sc].octave
+        //           << " relScale "
+        //           << vlevels[sc].relScale
+        //           << " " << vlevels[sc].shrScale
+        //           << " [" << (int)vlevels[sc].objSize.x
+        //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
+        // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
     }
+    levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
 }
 
 cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 821a2b140..f94b0b726 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -48,7 +48,7 @@ using cv::gpu::GpuMat;
 
 TEST(SoftCascade, readCascade)
 {
-    std::string xml = cvtest::TS::ptr()->get_data_path() + "cascadeandhog/icf-template.xml";
+    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
 
@@ -56,11 +56,12 @@ TEST(SoftCascade, readCascade)
 
 TEST(SoftCascade, detect)
 {
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + "cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
 
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + "cascadeandhog/bahnhof/image_00000000_0.png");
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
     GpuMat colored(coloredCpu), objectBoxes, rois;
 

From 1a52a322b50b7756464e8021f7225fa75f5a8dc2 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 16:10:40 +0400
Subject: [PATCH 011/155] add performance test for GPU soft cascade

---
 modules/gpu/perf/perf_objdetect.cpp | 39 +++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 6b864a3e5..cebcbdb63 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -89,6 +89,45 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
     SANITY_CHECK(found_locations);
 }
 
+typedef pair<string, string> pair_string;
+DEF_PARAM_TEST_1(SoftCascade, pair_string);
+
+PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml",
+                                                              "cv/cascadeandhog/bahnhof/image_00000000_0.png")))
+{
+    if (runOnGpu)
+    {
+        cv::Mat cpu = readImage(GetParam().second);
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
+
+        cv::gpu::SoftCascade cascade;
+        ASSERT_TRUE(cascade.load(GetParam().first));
+
+        cv::gpu::GpuMat rois, objectBoxes;
+        cascade.detectMultiScale(colored, rois, objectBoxes);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(colored, rois, objectBoxes);
+        }
+    } else
+    {
+        cv::Mat colored = readImage(GetParam().second);
+        ASSERT_FALSE(colored.empty());
+
+        cv::SoftCascade cascade;
+        ASSERT_TRUE(cascade.load(GetParam().first));
+
+        std::vector<cv::Rect> rois, objectBoxes;
+        cascade.detectMultiScale(colored, rois, objectBoxes);
+
+        TEST_CYCLE()
+        {
+            cascade.detectMultiScale(colored, rois, objectBoxes);
+        }
+    }
+}
 
 ///////////////////////////////////////////////////////////////
 // HaarClassifier

From 5d15e4ea58f8aa591d9be9d64ae4d22936fe0b88 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 16:12:18 +0400
Subject: [PATCH 012/155] CUDA kernels interface

---
 modules/gpu/src/cuda/isf-sc.cu  | 85 +++++++++++++++++++++++++++++++--
 modules/gpu/src/icf.hpp         | 27 ++++++++---
 modules/gpu/src/softcascade.cpp | 14 +++---
 3 files changed, 110 insertions(+), 16 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index a6418c1d3..89a74eeac 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -42,13 +42,90 @@
 
 #include <icf.hpp>
 
-void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv) const
+namespace cv { namespace gpu {
+
+
+ namespace device {
+
+__global__ void rgb2grayluv(const uchar3* __restrict__ rgb, uchar* __restrict__ hog,
+                            const int rgbPitch, const int hogPitch)
 {
-    // detection kernel
 }
 
-void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar4>& image)
+__global__ void gray2hog(const uchar* __restrict__ gray, uchar* __restrict__ hog,
+                         const int pitch)
+{
+}
+
+__global__ void decimate(const uchar* __restrict__ hogluv, uchar* __restrict__ shrank,
+                        const int inPitch, const int outPitch )
+{
+}
+
+__global__ void intRow(const uchar* __restrict__ hogluv, ushort* __restrict__ sum,
+                       const int inPitch, const int outPitch)
+{
+
+}
+
+__global__ void intCol(ushort* __restrict__ sum, const int pitch)
+{
+
+}
+
+
+__global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restrict__ hogluv, const int pitch)
+{
+    cascade.detectAt();
+}
+
+}
+
+void __device icf::Cascade::detectAt() const
+{
+
+}
+
+void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, cudaStream_t stream) const
+{
+    // detection kernel
+
+}
+
+void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream)
 {
     // color convertin kernel
+    dim3 block(32, 8);
+    dim3 grid(FRAME_WIDTH / 32, FRAME_HEIGHT / 8);
+
+    uchar * channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_BINS);
+    device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels, rgb.step, dmem.step);
+    cudaSafeCall( cudaGetLastError());
+
     // hog calculation kernel
-}
\ No newline at end of file
+    channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_LUV_BINS);
+    device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    const int shrWidth  = FRAME_WIDTH / shrinkage;
+    const int shrHeight = FRAME_HEIGHT / shrinkage;
+
+    // decimate kernel
+    grid = dim3(shrWidth / 32, shrHeight / 8);
+    device::decimate<<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    // integrate rows
+    block = dim3(shrWidth, 1);
+    grid = dim3(shrHeight * HOG_LUV_BINS, 1);
+    device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(), shrunk.step, hogluv.step);
+    cudaSafeCall( cudaGetLastError() );
+
+    // integrate cols
+    block = dim3(128, 1);
+    grid = dim3(shrWidth * HOG_LUV_BINS, 1);
+    device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step);
+    cudaSafeCall( cudaGetLastError() );
+}
+
+}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 7183fc0ac..8b075beba 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -46,17 +46,19 @@
 #define __OPENCV_ICF_HPP__
 
 #if defined __CUDACC__
-# define __hd__ __host__ __device__ __forceinline__
+# define __device __device__ __forceinline__
 #else
-# define __hd__
+# define __device
 #endif
 
 
-namespace icf {
+namespace cv { namespace gpu { namespace icf {
 
 using cv::gpu::PtrStepSzb;
 using cv::gpu::PtrStepSzf;
 
+typedef unsigned char uchar;
+
 struct Cascade
 {
     Cascade() {}
@@ -64,7 +66,8 @@ struct Cascade
         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
 
-    void detect(const cv::gpu::PtrStepSzb& hogluv) const;
+    void detect(const cv::gpu::PtrStepSzb& hogluv, cudaStream_t stream) const;
+    void __device detectAt() const;
 
     PtrStepSzb octaves;
     PtrStepSzf stages;
@@ -83,12 +86,24 @@ struct ChannelStorage
         const cv::gpu::PtrStepSzb& itg, const int s)
     : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
 
-    void frame(const cv::gpu::PtrStepSz<uchar4>& image);
+    void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream);
 
     PtrStepSzb dmem;
     PtrStepSzb shrunk;
     PtrStepSzb hogluv;
 
+    enum
+    {
+        FRAME_WIDTH        = 640,
+        FRAME_HEIGHT       = 480,
+        TOTAL_SCALES       = 55,
+        CLASSIFIERS        = 5,
+        ORIG_OBJECT_WIDTH  = 64,
+        ORIG_OBJECT_HEIGHT = 128,
+        HOG_BINS           = 6,
+        HOG_LUV_BINS       = 10
+    };
+
     int shrinkage;
 };
 
@@ -143,6 +158,6 @@ struct __align__(8) Level //is actually 24 bytes
         objSize.y  = round(oct.size.y * relScale);
     }
 };
-}
+}}}
 
 #endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index fb36efddc..b2419c12c 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -100,9 +100,9 @@ struct cv::gpu::SoftCascade::Filds
     };
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect() const
+    void detect(cudaStream_t stream) const
     {
-        cascade.detect(hogluv);
+        cascade.detect(hogluv, stream);
     }
 
 private:
@@ -394,18 +394,20 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
 }
 
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /*rois*/,
-                                GpuMat& /*objects*/, const int /*rejectfactor*/, Stream /*stream*/)
+                                GpuMat& /*objects*/, const int /*rejectfactor*/, Stream s)
 {
     // only color images are supperted
-    CV_Assert(image.type() == CV_8UC4);
+    CV_Assert(image.type() == CV_8UC3);
 
     // only this window size allowed
     CV_Assert(image.cols == 640 && image.rows == 480);
 
     Filds& flds = *filds;
 
-    flds.storage.frame(image);
-    flds.detect();
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    flds.storage.frame(image, stream);
+    flds.detect(stream);
 }
 
 #endif
\ No newline at end of file

From 0691dc554f046b880f61ad26526a798f01c12b34 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 18:49:51 +0400
Subject: [PATCH 013/155] fix compilation

---
 modules/gpu/src/cuda/texture_binder.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/cuda/texture_binder.hpp b/modules/gpu/src/cuda/texture_binder.hpp
index 4f42b099d..391eb9a19 100644
--- a/modules/gpu/src/cuda/texture_binder.hpp
+++ b/modules/gpu/src/cuda/texture_binder.hpp
@@ -85,7 +85,7 @@ namespace cv
 
   namespace device
   {
-      using pcl::gpu::TextureBinder;
+      using cv::gpu::TextureBinder;
   }
 }
 

From 1cf7a46f3a01c88fdbefc785943f4b4182ab4079 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 19:42:19 +0400
Subject: [PATCH 014/155] fix data paths in performance test

---
 modules/gpu/perf/perf_objdetect.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index cebcbdb63..a3a6e9c6b 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -97,12 +97,12 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
 {
     if (runOnGpu)
     {
-        cv::Mat cpu = readImage(GetParam().second);
+        cv::Mat cpu = readImage (GetParam().second);
         ASSERT_FALSE(cpu.empty());
         cv::gpu::GpuMat colored(cpu);
 
         cv::gpu::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(GetParam().first));
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
 
         cv::gpu::GpuMat rois, objectBoxes;
         cascade.detectMultiScale(colored, rois, objectBoxes);

From 08b4e780deb9ff6d7f1dc31031c317ea6b3bb6e6 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 21 Sep 2012 19:44:30 +0400
Subject: [PATCH 015/155] add shrinking kernel

---
 modules/gpu/src/cuda/isf-sc.cu | 132 +++++++++++++++++++++++++++++++--
 modules/gpu/src/icf.hpp        |   1 +
 2 files changed, 126 insertions(+), 7 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 89a74eeac..5cde71070 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -41,25 +41,136 @@
 //M*/
 
 #include <icf.hpp>
+#include <opencv2/gpu/device/saturate_cast.hpp>
 
 namespace cv { namespace gpu {
 
 
  namespace device {
 
+enum {
+    HOG_BINS = 6,
+    HOG_LUV_BINS = 10,
+    WIDTH = 640,
+    HEIGHT = 480,
+    GREY_OFFSET = HEIGHT * HOG_LUV_BINS
+};
+
+/* Returns the nearest upper power of two, works only for
+the typical GPU thread count (pert block) values */
+int power_2up(unsigned int n)
+{
+    if (n < 1) return 1;
+    else if (n < 2) return 2;
+    else if (n < 4) return 4;
+    else if (n < 8) return 8;
+    else if (n < 16) return 16;
+    else if (n < 32) return 32;
+    else if (n < 64) return 64;
+    else if (n < 128) return 128;
+    else if (n < 256) return 256;
+    else if (n < 512) return 512;
+    else if (n < 1024) return 1024;
+    return -1; // Input is too big
+}
+
+
+__device__ __forceinline__ uchar grey(const uchar3 rgb)
+{
+    return saturate_cast<uchar>(rgb.x * 0.114f + rgb.y * 0.587f + rgb.z * 0.299f);
+}
+
+__device__ __forceinline__ void luv(const uchar3 rgb, uchar& l, uchar& u, uchar& v)
+{
+
+}
+
 __global__ void rgb2grayluv(const uchar3* __restrict__ rgb, uchar* __restrict__ hog,
                             const int rgbPitch, const int hogPitch)
 {
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+    const uchar3 color = rgb[rgbPitch * y + x];
+
+    uchar l, u, v;
+    luv(color, l, u, v);
+
+    hog[hogPitch *  y + x] = l;
+    hog[hogPitch * (y + HEIGHT) + x] = u;
+    hog[hogPitch * (y + 2 * HEIGHT) + x] = v;
+    hog[hogPitch * (y + 3 * HEIGHT) + x] = grey(color);
 }
 
-__global__ void gray2hog(const uchar* __restrict__ gray, uchar* __restrict__ hog,
-                         const int pitch)
+__device__ __forceinline__
+int qangle(const float &y, const float &x)
 {
+    int bin = 0;
+//     const float2 &bin_vector_zero = const_angle_bins_vectors[0];
+//     float max_dot_product = fabs(x*bin_vector_zero.x + y*bin_vector_zero.y);
+
+//     // let us hope this gets unrolled
+// #pragma unroll
+//     for(int i=1; i < num_angles_bin; i+=1)
+//     {
+//         const float2 &bin_vector_i = const_angle_bins_vectors[i];
+//         //const float2 bin_vector_i = const_angle_bins_vectors[i];
+//         //const float2 &bin_vector_i = angle_bins_vectors[i];
+//         const float dot_product = fabs(x*bin_vector_i.x + y*bin_vector_i.y);
+//         if(dot_product > max_dot_product)
+//         {
+//             max_dot_product = dot_product;
+//             index = i;
+//         }
+//     }
+
+    return bin;
 }
 
+// texture<uchar, 2, cudaReadModeElementType> tgray;
+__global__ void gray2hog(const uchar* __restrict__ gray, uchar* __restrict__ hog, const int pitch, const float norm)
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+    // derivative
+    float dx = gray[y * pitch + x + 1];
+    dx -= gray[y * pitch + x - 1];
+
+    float dy = gray[(y + 1) * pitch + x];
+    dy -= gray[(y -1) * pitch + x - 1];
+
+    // mag and angle
+    const uchar mag =  saturate_cast<uchar>(sqrtf(dy * dy + dx * dx) * norm);
+    const int bin = qangle(dx, dy);
+
+}
+
+template <int FACTOR>
+__device__ __forceinline__ uchar shrink(const uchar* ptr, const int pitch, const int y, const int x)
+{
+    int out = 0;
+#pragma unroll
+    for(int dy = 0; dy < FACTOR; ++dy)
+#pragma unroll
+        for(int dx = 0; dx < FACTOR; ++dx)
+        {
+            out += ptr[dy * pitch + dx];
+        }
+
+    return saturate_cast<uchar>(out / FACTOR);
+}
+
+template<int FACTOR>
 __global__ void decimate(const uchar* __restrict__ hogluv, uchar* __restrict__ shrank,
                         const int inPitch, const int outPitch )
 {
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+    const uchar* ptr = hogluv + (FACTOR * y) * inPitch + (FACTOR * x);
+
+    shrank[ y * outPitch + x]= shrink<FACTOR>(ptr, inPitch, y, x);
 }
 
 __global__ void intRow(const uchar* __restrict__ hogluv, ushort* __restrict__ sum,
@@ -89,6 +200,11 @@ void __device icf::Cascade::detectAt() const
 void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, cudaStream_t stream) const
 {
     // detection kernel
+    dim3 block(32, 8, 1);
+    dim3 grid(32 * ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 64);
+    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(ushort));
+    if (!stream)
+        cudaSafeCall( cudaDeviceSynchronize() );
 
 }
 
@@ -99,12 +215,13 @@ void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStrea
     dim3 grid(FRAME_WIDTH / 32, FRAME_HEIGHT / 8);
 
     uchar * channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_BINS);
-    device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels, rgb.step, dmem.step);
+    device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels,
+                                                    rgb.step / sizeof(uchar3), dmem.step);
     cudaSafeCall( cudaGetLastError());
 
     // hog calculation kernel
     channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_LUV_BINS);
-    device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step);
+    device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step, magnitudeScaling);
     cudaSafeCall( cudaGetLastError() );
 
     const int shrWidth  = FRAME_WIDTH / shrinkage;
@@ -112,19 +229,20 @@ void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStrea
 
     // decimate kernel
     grid = dim3(shrWidth / 32, shrHeight / 8);
-    device::decimate<<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
+    device::decimate<4><<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
     cudaSafeCall( cudaGetLastError() );
 
     // integrate rows
     block = dim3(shrWidth, 1);
     grid = dim3(shrHeight * HOG_LUV_BINS, 1);
-    device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(), shrunk.step, hogluv.step);
+    device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(),
+        shrunk.step, hogluv.step / sizeof(ushort));
     cudaSafeCall( cudaGetLastError() );
 
     // integrate cols
     block = dim3(128, 1);
     grid = dim3(shrWidth * HOG_LUV_BINS, 1);
-    device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step);
+    device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step / hogluv.step / sizeof(ushort));
     cudaSafeCall( cudaGetLastError() );
 }
 
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 8b075beba..69d21fdd9 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -105,6 +105,7 @@ struct ChannelStorage
     };
 
     int shrinkage;
+    static const float magnitudeScaling = 1.f ;// / sqrt(2);
 };
 
 struct __align__(16) Octave

From 1bf85996b37d4d8995041050f6e0d03f2beca4bc Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 24 Sep 2012 17:59:44 +0400
Subject: [PATCH 016/155] add detections vector initialization in tests

---
 modules/gpu/perf/perf_objdetect.cpp   | 2 +-
 modules/gpu/test/test_softcascade.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index a3a6e9c6b..48a355d6a 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -104,7 +104,7 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
         cv::gpu::SoftCascade cascade;
         ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
 
-        cv::gpu::GpuMat rois, objectBoxes;
+        cv::gpu::GpuMat rois, objectBoxes(1, 1000, CV_8UC1);
         cascade.detectMultiScale(colored, rois, objectBoxes);
 
         TEST_CYCLE()
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index f94b0b726..c7e3a1f77 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -63,7 +63,7 @@ TEST(SoftCascade, detect)
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
         + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
-    GpuMat colored(coloredCpu), objectBoxes, rois;
+    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois;
 
     // ASSERT_NO_THROW(
     // {

From ba50d193412677954cff9a4a53c4ebe31e2e9661 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 24 Sep 2012 18:00:47 +0400
Subject: [PATCH 017/155] first version of soft cascade on GPU

---
 modules/gpu/src/cuda/isf-sc.cu  | 219 ++++++++++++++++++++++++++------
 modules/gpu/src/icf.hpp         |  78 ++++++------
 modules/gpu/src/softcascade.cpp |  98 ++++++++++++--
 3 files changed, 311 insertions(+), 84 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 5cde71070..37c6e3023 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -42,11 +42,48 @@
 
 #include <icf.hpp>
 #include <opencv2/gpu/device/saturate_cast.hpp>
+#include <stdio.h>
+#include <float.h>
 
-namespace cv { namespace gpu {
+namespace cv { namespace gpu { namespace device {
 
+namespace icf {
 
- namespace device {
+    enum {
+        HOG_BINS = 6,
+        HOG_LUV_BINS = 10,
+        WIDTH = 640,
+        HEIGHT = 480,
+        GREY_OFFSET = HEIGHT * HOG_LUV_BINS
+    };
+
+    __global__ void magToHist(const uchar* __restrict__ mag,
+                              const float* __restrict__ angle, const int angPitch,
+                                    uchar* __restrict__ hog,   const int hogPitch)
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+        const int bin = (int)(angle[y * angPitch + x]);
+        const uchar val = mag[y * angPitch + x];
+
+        hog[((HEIGHT * bin) + y) * hogPitch + x] = val;
+    }
+
+    void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle)
+    {
+        const uchar* mag = (const uchar*)hogluv.ptr(HEIGHT * HOG_BINS);
+        uchar* hog = (uchar*)hogluv.ptr();
+        const float* angle = (const float*)nangle.ptr();
+
+        dim3 block(32, 8);
+        dim3 grid(WIDTH / 32, HEIGHT / 8);
+
+        magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step);
+        cudaSafeCall( cudaGetLastError() );
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
 
 enum {
     HOG_BINS = 6,
@@ -185,65 +222,175 @@ __global__ void intCol(ushort* __restrict__ sum, const int pitch)
 }
 
 
-__global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restrict__ hogluv, const int pitch)
+__global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restrict__ hogluv, const int pitch,
+    PtrStepSz<uchar4> objects)
 {
-    cascade.detectAt();
+    cascade.detectAt(hogluv, pitch, objects);
 }
 
 }
 
-void __device icf::Cascade::detectAt() const
+float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
+                                     const int channel, const float threshold) const
 {
+    float relScale = level.relScale;
+    float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
+    // rescale
+    scaledRect.x = __float2int_rn(relScale * scaledRect.x);
+    scaledRect.y = __float2int_rn(relScale * scaledRect.y);
+    scaledRect.z = __float2int_rn(relScale * scaledRect.z);
+    scaledRect.w = __float2int_rn(relScale * scaledRect.w);
+
+    float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
+
+    float approx = 1.f;
+    if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
+    {
+        const float expected_new_area = farea * relScale * relScale;
+        approx = expected_new_area / sarea;
+    }
+
+    // compensation areas rounding
+    float rootThreshold = threshold / approx;
+    rootThreshold *= level.scaling[(int)(channel > 6)];
+
+    return rootThreshold;
 }
 
-void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, cudaStream_t stream) const
+typedef unsigned char uchar;
+float __device get(const uchar* __restrict__ hogluv, const int pitch,
+                   const int x, const int y, int channel, uchar4 area)
+{
+    const uchar* curr = hogluv + ((channel * 121) + y) * pitch;
+
+    int a = curr[area.y * pitch + x + area.x];
+    int b = curr[area.y * pitch + x + area.z];
+    int c = curr[area.w * pitch + x + area.z];
+    int d = curr[area.w * pitch + x + area.x];
+
+    return (a - b + c - d);
+}
+
+
+void __device icf::Cascade::detectAt(const uchar* __restrict__ hogluv, const int pitch,
+                                    PtrStepSz<uchar4>& objects) const
+{
+    const icf::Level* lls = (const icf::Level*)levels.ptr();
+    Level level = lls[0];
+
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+    if (x >= level.workRect.x || y >= level.workRect.y) return;
+
+    const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
+    const int stBegin = octave.index * octave.stages, stEnd = stBegin + octave.stages;
+
+    float detectionScore = 0.f;
+
+    int st = stBegin;
+    for(; st < stEnd; ++st)
+    {
+        const float stage = stages(0, st);
+        {
+            const int nId = st * 3;
+
+            // work with root node
+            const Node node = ((const Node*)nodes.ptr())[nId];
+            const Feature feature = ((const Feature*)features.ptr())[node.feature];
+
+            uchar4 scaledRect = feature.rect;
+            float threshold = rescale(level, scaledRect, feature.channel, node.threshold);
+
+            float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
+
+            int next = 1 + (int)(sum >= threshold);
+
+            // leaves
+            const Node leaf = ((const Node*)nodes.ptr())[nId + next];
+            const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
+
+            scaledRect = fLeaf.rect;
+            threshold = rescale(level, scaledRect, feature.channel, node.threshold);
+            sum = get(hogluv, pitch, x, y, fLeaf.channel, scaledRect);
+
+            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+            float impact = leaves(0, (st * 4) + lShift);
+
+            detectionScore += impact;
+        }
+
+        if (detectionScore <= stage) break;
+    }
+
+    // if (!threadIdx.x && !threadIdx.y)// printf("%f %d\n", detectionScore, st);
+    //     printf("x %d y %d: %d\n", x, y, st);
+
+    if (st == stEnd)
+    {
+        // printf("  got %d\n", st);
+        uchar4 a;
+        a.x = level.workRect.x;
+        a.y = level.workRect.y;
+        objects(0, threadIdx.x) = a;
+    }
+}
+
+void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, PtrStepSz<uchar4> objects,
+                          cudaStream_t stream) const
 {
     // detection kernel
     dim3 block(32, 8, 1);
-    dim3 grid(32 * ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 64);
-    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(ushort));
+    // dim3 grid(32 * ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 1);
+    dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 1);
+    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(ushort), objects);
+    cudaSafeCall( cudaGetLastError() );
     if (!stream)
         cudaSafeCall( cudaDeviceSynchronize() );
 
 }
 
+////////////////////////////////////////////////////
+
+
+
 void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream)
 {
-    // color convertin kernel
-    dim3 block(32, 8);
-    dim3 grid(FRAME_WIDTH / 32, FRAME_HEIGHT / 8);
+//     // // color convertin kernel
+//     // dim3 block(32, 8);
+//     // dim3 grid(FRAME_WIDTH / 32, FRAME_HEIGHT / 8);
 
-    uchar * channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_BINS);
-    device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels,
-                                                    rgb.step / sizeof(uchar3), dmem.step);
-    cudaSafeCall( cudaGetLastError());
+//     // uchar * channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_BINS);
+//     // device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels,
+//     //                                                 rgb.step / sizeof(uchar3), dmem.step);
+//     // cudaSafeCall( cudaGetLastError());
 
-    // hog calculation kernel
-    channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_LUV_BINS);
-    device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step, magnitudeScaling);
-    cudaSafeCall( cudaGetLastError() );
+//     // // hog calculation kernel
+//     // channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_LUV_BINS);
+//     // device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step, magnitudeScaling);
+//     // cudaSafeCall( cudaGetLastError() );
 
-    const int shrWidth  = FRAME_WIDTH / shrinkage;
-    const int shrHeight = FRAME_HEIGHT / shrinkage;
+//     // const int shrWidth  = FRAME_WIDTH / shrinkage;
+//     // const int shrHeight = FRAME_HEIGHT / shrinkage;
 
-    // decimate kernel
-    grid = dim3(shrWidth / 32, shrHeight / 8);
-    device::decimate<4><<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
-    cudaSafeCall( cudaGetLastError() );
+//     // // decimate kernel
+//     // grid = dim3(shrWidth / 32, shrHeight / 8);
+//     // device::decimate<4><<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
+//     // cudaSafeCall( cudaGetLastError() );
 
-    // integrate rows
-    block = dim3(shrWidth, 1);
-    grid = dim3(shrHeight * HOG_LUV_BINS, 1);
-    device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(),
-        shrunk.step, hogluv.step / sizeof(ushort));
-    cudaSafeCall( cudaGetLastError() );
+//     // // integrate rows
+//     // block = dim3(shrWidth, 1);
+//     // grid = dim3(shrHeight * HOG_LUV_BINS, 1);
+//     // device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(),
+//     //     shrunk.step, hogluv.step / sizeof(ushort));
+//     // cudaSafeCall( cudaGetLastError() );
 
-    // integrate cols
-    block = dim3(128, 1);
-    grid = dim3(shrWidth * HOG_LUV_BINS, 1);
-    device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step / hogluv.step / sizeof(ushort));
-    cudaSafeCall( cudaGetLastError() );
+//     // // integrate cols
+//     // block = dim3(128, 1);
+//     // grid = dim3(shrWidth * HOG_LUV_BINS, 1);
+//     // device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step / hogluv.step / sizeof(ushort));
+//     // cudaSafeCall( cudaGetLastError() );
 }
 
 }}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 69d21fdd9..454dad881 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -59,6 +59,42 @@ using cv::gpu::PtrStepSzf;
 
 typedef unsigned char uchar;
 
+struct __align__(16) Octave
+{
+    ushort index;
+    ushort stages;
+    ushort shrinkage;
+    ushort2 size;
+    float scale;
+
+    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+};
+
+struct __align__(8) Level //is actually 24 bytes
+{
+    int octave;
+
+    // float origScale; //not actually used
+    float relScale;
+    float shrScale;   // used for marking detection
+    float scaling[2]; // calculated according to Dollal paper
+
+    // for 640x480 we can not get overflow
+    uchar2 workRect;
+    uchar2 objSize;
+
+    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+    {
+        workRect.x = round(w / (float)oct.shrinkage);
+        workRect.y = round(h / (float)oct.shrinkage);
+
+        objSize.x  = round(oct.size.x * relScale);
+        objSize.y  = round(oct.size.y * relScale);
+    }
+};
+
 struct Cascade
 {
     Cascade() {}
@@ -66,8 +102,10 @@ struct Cascade
         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
 
-    void detect(const cv::gpu::PtrStepSzb& hogluv, cudaStream_t stream) const;
-    void __device detectAt() const;
+    void detect(const cv::gpu::PtrStepSzb& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
+    void __device detectAt(const uchar* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
+    float __device rescale(const icf::Level& level, uchar4& scaledRect,
+                           const int channel, const float threshold) const;
 
     PtrStepSzb octaves;
     PtrStepSzf stages;
@@ -108,18 +146,6 @@ struct ChannelStorage
     static const float magnitudeScaling = 1.f ;// / sqrt(2);
 };
 
-struct __align__(16) Octave
-{
-    ushort index;
-    ushort stages;
-    ushort shrinkage;
-    ushort2 size;
-    float scale;
-
-    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
-    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
-};
-
 struct __align__(8) Node
 {
     int feature;
@@ -135,30 +161,6 @@ struct __align__(8) Feature
 
     Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
 };
-
-struct __align__(8) Level //is actually 24 bytes
-{
-    int octave;
-
-    // float origScale; //not actually used
-    float relScale;
-    float shrScale;   // used for marking detection
-    float scaling[2]; // calculated according to Dollal paper
-
-    // for 640x480 we can not get overflow
-    uchar2 workRect;
-    uchar2 objSize;
-
-    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-    {
-        workRect.x = round(w / (float)oct.shrinkage);
-        workRect.y = round(h / (float)oct.shrinkage);
-
-        objSize.x  = round(oct.size.x * relScale);
-        objSize.y  = round(oct.size.y * relScale);
-    }
-};
 }}}
 
 #endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index b2419c12c..abcae73dc 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -41,6 +41,7 @@
 //M*/
 
 #include <precomp.hpp>
+#include "opencv2/highgui/highgui.hpp"
 
 #if !defined (HAVE_CUDA)
 
@@ -58,6 +59,12 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat
 
 #include <icf.hpp>
 
+namespace cv { namespace gpu { namespace device {
+namespace icf {
+    void fillBins(cv::gpu::PtrStepSzb hogluv,const cv::gpu::PtrStepSzf& nangle);
+}
+}}}
+
 struct cv::gpu::SoftCascade::Filds
 {
     // scales range
@@ -81,6 +88,16 @@ struct cv::gpu::SoftCascade::Filds
     // 161x121x10
     GpuMat hogluv;
 
+    // will be removed in final version
+    // temporial mat for cvtColor
+    GpuMat luv;
+
+    // temporial mat for integrall
+    GpuMat integralBuffer;
+
+    // temp matrix for sobel and cartToPolar
+    GpuMat dfdx, dfdy, angle, mag, nmag, nangle;
+
     std::vector<float> scales;
 
     icf::Cascade cascade;
@@ -100,9 +117,9 @@ struct cv::gpu::SoftCascade::Filds
     };
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(cudaStream_t stream) const
+    void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
-        cascade.detect(hogluv, stream);
+        cascade.detect(hogluv, objects, stream);
     }
 
 private:
@@ -284,7 +301,18 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     // allocate buffers
     dmem.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
-    hogluv.create( (FRAME_HEIGHT / shrinkage * HOG_LUV_BINS) + 1, (FRAME_WIDTH / shrinkage) + 1, CV_16UC1);
+    // hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_16UC1);
+    hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_32SC1);
+    luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
+    integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
+
+    dfdx.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+    dfdy.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+    angle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+    mag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+
+    nmag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+    nangle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
 
     storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
     return true;
@@ -393,21 +421,71 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     return true;
 }
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& image, const GpuMat& /*rois*/,
-                                GpuMat& /*objects*/, const int /*rejectfactor*/, Stream s)
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
+                                GpuMat& objects, const int /*rejectfactor*/, Stream s)
 {
     // only color images are supperted
-    CV_Assert(image.type() == CV_8UC3);
+    CV_Assert(colored.type() == CV_8UC3);
 
-    // only this window size allowed
-    CV_Assert(image.cols == 640 && image.rows == 480);
+    // // only this window size allowed
+    CV_Assert(colored.cols == 640 && colored.rows == 480);
 
     Filds& flds = *filds;
+    GpuMat& dmem = flds.dmem;
+    cudaMemset(dmem.data, 0, dmem.step * dmem.rows);
+    GpuMat& shrunk = flds.shrunk;
+    int w = shrunk.cols;
+    int h = colored.rows / flds.storage.shrinkage;
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    flds.storage.frame(image, stream);
-    flds.detect(stream);
+    std::vector<GpuMat> splited;
+    for(int i = 0; i < 3; ++i)
+    {
+        splited.push_back(GpuMat(dmem, cv::Rect(0, colored.rows * (7 + i), colored.cols, colored.rows)));
+    }
+
+    GpuMat gray(dmem, cv::Rect(0, colored.rows * 10, colored.cols, colored.rows) );
+
+    cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
+
+    //create hog
+    cv::gpu::Sobel(gray, flds.dfdx, CV_32F, 1, 0, 3, 0.25);
+    cv::gpu::Sobel(gray, flds.dfdy, CV_32F, 0, 1, 3, 0.25);
+
+    cv::gpu::cartToPolar(flds.dfdx, flds.dfdy, flds.mag, flds.angle, true);
+
+    cv::gpu::multiply(flds.mag, cv::Scalar::all(1.0 / ::log(2)), flds.nmag);
+    cv::gpu::multiply(flds.angle, cv::Scalar::all(1.0 / 60.0), flds.nangle);
+
+    GpuMat magCannel(dmem, cv::Rect(0, colored.rows * 6, colored.cols, colored.rows));
+    flds.nmag.convertTo(magCannel, CV_8UC1);
+    device::icf::fillBins(dmem, flds.nangle);
+
+    // create luv
+    cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
+    cv::gpu::split(flds.luv, splited);
+
+    GpuMat plane(dmem, cv::Rect(0, 0, colored.cols, colored.rows * Filds::HOG_LUV_BINS));
+    cv::gpu::resize(plane, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+    // cv::Mat cpu(plane);
+    // cv::imshow("channels", cpu);
+    // cv::waitKey(0);
+
+    // fer debug purpose
+    // cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
+
+    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+    {
+        GpuMat channel(shrunk, cv::Rect(0, h  * i, w, h ));
+        GpuMat sum(flds.hogluv, cv::Rect(0, (h + 1) * i, w + 1, h + 1));
+        cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
+    }
+
+    // detection
+    flds.detect(objects, stream);
+
+    // flds.storage.frame(colored, stream);
 }
 
 #endif
\ No newline at end of file

From e606a0d6519eadffba18e6060ace334f408c4411 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 24 Sep 2012 18:05:08 +0400
Subject: [PATCH 018/155] remove dead code

---
 modules/gpu/src/cuda/isf-sc.cu | 179 ---------------------------------
 modules/gpu/src/icf.hpp        |   2 +-
 2 files changed, 1 insertion(+), 180 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 37c6e3023..b5eb5ad17 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -85,143 +85,6 @@ namespace icf {
     }
 }
 
-enum {
-    HOG_BINS = 6,
-    HOG_LUV_BINS = 10,
-    WIDTH = 640,
-    HEIGHT = 480,
-    GREY_OFFSET = HEIGHT * HOG_LUV_BINS
-};
-
-/* Returns the nearest upper power of two, works only for
-the typical GPU thread count (pert block) values */
-int power_2up(unsigned int n)
-{
-    if (n < 1) return 1;
-    else if (n < 2) return 2;
-    else if (n < 4) return 4;
-    else if (n < 8) return 8;
-    else if (n < 16) return 16;
-    else if (n < 32) return 32;
-    else if (n < 64) return 64;
-    else if (n < 128) return 128;
-    else if (n < 256) return 256;
-    else if (n < 512) return 512;
-    else if (n < 1024) return 1024;
-    return -1; // Input is too big
-}
-
-
-__device__ __forceinline__ uchar grey(const uchar3 rgb)
-{
-    return saturate_cast<uchar>(rgb.x * 0.114f + rgb.y * 0.587f + rgb.z * 0.299f);
-}
-
-__device__ __forceinline__ void luv(const uchar3 rgb, uchar& l, uchar& u, uchar& v)
-{
-
-}
-
-__global__ void rgb2grayluv(const uchar3* __restrict__ rgb, uchar* __restrict__ hog,
-                            const int rgbPitch, const int hogPitch)
-{
-    const int y = blockIdx.y * blockDim.y + threadIdx.y;
-    const int x = blockIdx.x * blockDim.x + threadIdx.x;
-
-    const uchar3 color = rgb[rgbPitch * y + x];
-
-    uchar l, u, v;
-    luv(color, l, u, v);
-
-    hog[hogPitch *  y + x] = l;
-    hog[hogPitch * (y + HEIGHT) + x] = u;
-    hog[hogPitch * (y + 2 * HEIGHT) + x] = v;
-    hog[hogPitch * (y + 3 * HEIGHT) + x] = grey(color);
-}
-
-__device__ __forceinline__
-int qangle(const float &y, const float &x)
-{
-    int bin = 0;
-//     const float2 &bin_vector_zero = const_angle_bins_vectors[0];
-//     float max_dot_product = fabs(x*bin_vector_zero.x + y*bin_vector_zero.y);
-
-//     // let us hope this gets unrolled
-// #pragma unroll
-//     for(int i=1; i < num_angles_bin; i+=1)
-//     {
-//         const float2 &bin_vector_i = const_angle_bins_vectors[i];
-//         //const float2 bin_vector_i = const_angle_bins_vectors[i];
-//         //const float2 &bin_vector_i = angle_bins_vectors[i];
-//         const float dot_product = fabs(x*bin_vector_i.x + y*bin_vector_i.y);
-//         if(dot_product > max_dot_product)
-//         {
-//             max_dot_product = dot_product;
-//             index = i;
-//         }
-//     }
-
-    return bin;
-}
-
-// texture<uchar, 2, cudaReadModeElementType> tgray;
-__global__ void gray2hog(const uchar* __restrict__ gray, uchar* __restrict__ hog, const int pitch, const float norm)
-{
-    const int y = blockIdx.y * blockDim.y + threadIdx.y;
-    const int x = blockIdx.x * blockDim.x + threadIdx.x;
-
-    // derivative
-    float dx = gray[y * pitch + x + 1];
-    dx -= gray[y * pitch + x - 1];
-
-    float dy = gray[(y + 1) * pitch + x];
-    dy -= gray[(y -1) * pitch + x - 1];
-
-    // mag and angle
-    const uchar mag =  saturate_cast<uchar>(sqrtf(dy * dy + dx * dx) * norm);
-    const int bin = qangle(dx, dy);
-
-}
-
-template <int FACTOR>
-__device__ __forceinline__ uchar shrink(const uchar* ptr, const int pitch, const int y, const int x)
-{
-    int out = 0;
-#pragma unroll
-    for(int dy = 0; dy < FACTOR; ++dy)
-#pragma unroll
-        for(int dx = 0; dx < FACTOR; ++dx)
-        {
-            out += ptr[dy * pitch + dx];
-        }
-
-    return saturate_cast<uchar>(out / FACTOR);
-}
-
-template<int FACTOR>
-__global__ void decimate(const uchar* __restrict__ hogluv, uchar* __restrict__ shrank,
-                        const int inPitch, const int outPitch )
-{
-    const int y = blockIdx.y * blockDim.y + threadIdx.y;
-    const int x = blockIdx.x * blockDim.x + threadIdx.x;
-
-    const uchar* ptr = hogluv + (FACTOR * y) * inPitch + (FACTOR * x);
-
-    shrank[ y * outPitch + x]= shrink<FACTOR>(ptr, inPitch, y, x);
-}
-
-__global__ void intRow(const uchar* __restrict__ hogluv, ushort* __restrict__ sum,
-                       const int inPitch, const int outPitch)
-{
-
-}
-
-__global__ void intCol(ushort* __restrict__ sum, const int pitch)
-{
-
-}
-
-
 __global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restrict__ hogluv, const int pitch,
     PtrStepSz<uchar4> objects)
 {
@@ -351,46 +214,4 @@ void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, PtrStepSz<uchar4> o
 
 }
 
-////////////////////////////////////////////////////
-
-
-
-void icf::ChannelStorage::frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream)
-{
-//     // // color convertin kernel
-//     // dim3 block(32, 8);
-//     // dim3 grid(FRAME_WIDTH / 32, FRAME_HEIGHT / 8);
-
-//     // uchar * channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_BINS);
-//     // device::rgb2grayluv<<<grid, block, 0, stream>>>((uchar3*)rgb.ptr(), channels,
-//     //                                                 rgb.step / sizeof(uchar3), dmem.step);
-//     // cudaSafeCall( cudaGetLastError());
-
-//     // // hog calculation kernel
-//     // channels = (uchar*)dmem.ptr(FRAME_HEIGHT * HOG_LUV_BINS);
-//     // device::gray2hog<<<grid, block, 0, stream>>>(channels, (uchar*)dmem.ptr(), dmem.step, magnitudeScaling);
-//     // cudaSafeCall( cudaGetLastError() );
-
-//     // const int shrWidth  = FRAME_WIDTH / shrinkage;
-//     // const int shrHeight = FRAME_HEIGHT / shrinkage;
-
-//     // // decimate kernel
-//     // grid = dim3(shrWidth / 32, shrHeight / 8);
-//     // device::decimate<4><<<grid, block, 0, stream>>>((uchar*)dmem.ptr(), (uchar*)shrunk.ptr(), dmem.step, shrunk.step);
-//     // cudaSafeCall( cudaGetLastError() );
-
-//     // // integrate rows
-//     // block = dim3(shrWidth, 1);
-//     // grid = dim3(shrHeight * HOG_LUV_BINS, 1);
-//     // device::intRow<<<grid, block, 0, stream>>>((uchar*)shrunk.ptr(), (ushort*)hogluv.ptr(),
-//     //     shrunk.step, hogluv.step / sizeof(ushort));
-//     // cudaSafeCall( cudaGetLastError() );
-
-//     // // integrate cols
-//     // block = dim3(128, 1);
-//     // grid = dim3(shrWidth * HOG_LUV_BINS, 1);
-//     // device::intCol<<<grid, block, 0, stream>>>((ushort*)hogluv.ptr(), hogluv.step / hogluv.step / sizeof(ushort));
-//     // cudaSafeCall( cudaGetLastError() );
-}
-
 }}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 454dad881..a8ce8d483 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -124,7 +124,7 @@ struct ChannelStorage
         const cv::gpu::PtrStepSzb& itg, const int s)
     : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
 
-    void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream);
+    void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream){}
 
     PtrStepSzb dmem;
     PtrStepSzb shrunk;

From dca27b4622c711f52797c126c0b2aba72f421497 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Tue, 25 Sep 2012 11:32:03 +0400
Subject: [PATCH 019/155] fix cast bug; add logging

---
 modules/gpu/src/cuda/isf-sc.cu  | 87 +++++++++++++++++++++++++++------
 modules/gpu/src/icf.hpp         |  4 +-
 modules/gpu/src/softcascade.cpp | 34 +++++++++++--
 3 files changed, 103 insertions(+), 22 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index b5eb5ad17..6572c54fc 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -45,6 +45,8 @@
 #include <stdio.h>
 #include <float.h>
 
+//#define LOG_CUDA_CASCADE
+
 namespace cv { namespace gpu { namespace device {
 
 namespace icf {
@@ -85,7 +87,7 @@ namespace icf {
     }
 }
 
-__global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restrict__ hogluv, const int pitch,
+__global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restrict__ hogluv, const int pitch,
     PtrStepSz<uchar4> objects)
 {
     cascade.detectAt(hogluv, pitch, objects);
@@ -96,6 +98,11 @@ __global__ void detect(const cv::gpu::icf::Cascade cascade, const uchar* __restr
 float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
                                      const int channel, const float threshold) const
 {
+#if defined LOG_CUDA_CASCADE
+    printf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
+    printf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
+#endif
+
     float relScale = level.relScale;
     float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
@@ -107,6 +114,7 @@ float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect
 
     float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
+
     float approx = 1.f;
     if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
     {
@@ -114,40 +122,72 @@ float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect
         approx = expected_new_area / sarea;
     }
 
+#if defined LOG_CUDA_CASCADE
+    printf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
+        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
+#endif
+
     // compensation areas rounding
     float rootThreshold = threshold / approx;
+    // printf("    approx %f\n", rootThreshold);
     rootThreshold *= level.scaling[(int)(channel > 6)];
 
+#if defined LOG_CUDA_CASCADE
+    printf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
+#endif
+
     return rootThreshold;
 }
 
 typedef unsigned char uchar;
-float __device get(const uchar* __restrict__ hogluv, const int pitch,
+float __device get(const int* __restrict__ hogluv, const int pitch,
                    const int x, const int y, int channel, uchar4 area)
 {
-    const uchar* curr = hogluv + ((channel * 121) + y) * pitch;
+#if defined LOG_CUDA_CASCADE
+    printf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
+    printf("get for channel %d\n", channel);
+    printf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
+        x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
+        x + area.x, y + area.w);
+    printf("at point %d %d with offset %d\n", x, y, 0);
+#endif
+
+    const int* curr = hogluv + ((channel * 121) + y) * pitch;
 
     int a = curr[area.y * pitch + x + area.x];
     int b = curr[area.y * pitch + x + area.z];
     int c = curr[area.w * pitch + x + area.z];
     int d = curr[area.w * pitch + x + area.x];
 
+#if defined LOG_CUDA_CASCADE
+    printf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
+#endif
+
     return (a - b + c - d);
 }
 
 
-void __device icf::Cascade::detectAt(const uchar* __restrict__ hogluv, const int pitch,
+void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int pitch,
                                     PtrStepSz<uchar4>& objects) const
 {
     const icf::Level* lls = (const icf::Level*)levels.ptr();
-    Level level = lls[0];
 
     const int y = blockIdx.y * blockDim.y + threadIdx.y;
     const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    // if (x > 0 || y > 0) return;
 
+    Level level = lls[0];
     if (x >= level.workRect.x || y >= level.workRect.y) return;
 
+#if defined LOG_CUDA_CASCADE
+    printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+        level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
+#endif
+
     const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
+    // printf("Octave: %d %d %d (%d %d) %f\n", octave.index, octave.stages,
+    //     octave.shrinkage, octave.size.x, octave.size.y, octave.scale);
+
     const int stBegin = octave.index * octave.stages, stEnd = stBegin + octave.stages;
 
     float detectionScore = 0.f;
@@ -156,11 +196,17 @@ void __device icf::Cascade::detectAt(const uchar* __restrict__ hogluv, const int
     for(; st < stEnd; ++st)
     {
         const float stage = stages(0, st);
+#if defined LOG_CUDA_CASCADE
+        printf("Stage: %f\n", stage);
+#endif
         {
             const int nId = st * 3;
 
             // work with root node
             const Node node = ((const Node*)nodes.ptr())[nId];
+#if defined LOG_CUDA_CASCADE
+            printf("Node: %d %f\n", node.feature, node.threshold);
+#endif
             const Feature feature = ((const Feature*)features.ptr())[node.feature];
 
             uchar4 scaledRect = feature.rect;
@@ -168,31 +214,46 @@ void __device icf::Cascade::detectAt(const uchar* __restrict__ hogluv, const int
 
             float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
 
+#if defined LOG_CUDA_CASCADE
+            printf("root feature %d %f\n",feature.channel, sum);
+#endif
             int next = 1 + (int)(sum >= threshold);
 
+#if defined LOG_CUDA_CASCADE
+            printf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
+#endif
             // leaves
             const Node leaf = ((const Node*)nodes.ptr())[nId + next];
             const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
 
             scaledRect = fLeaf.rect;
-            threshold = rescale(level, scaledRect, feature.channel, node.threshold);
+            threshold = rescale(level, scaledRect, fLeaf.channel, leaf.threshold);
             sum = get(hogluv, pitch, x, y, fLeaf.channel, scaledRect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
             float impact = leaves(0, (st * 4) + lShift);
 
             detectionScore += impact;
+
+#if defined LOG_CUDA_CASCADE
+            printf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+            printf("extracted stage:\n");
+            printf("ct %f\n", stage);
+            printf("computed score %f\n\n", detectionScore);
+            printf("\n\n");
+#endif
+
         }
 
         if (detectionScore <= stage) break;
     }
 
-    // if (!threadIdx.x && !threadIdx.y)// printf("%f %d\n", detectionScore, st);
-    //     printf("x %d y %d: %d\n", x, y, st);
+#if defined LOG_CUDA_CASCADE
+    // printf("x %d y %d: %d\n", x, y, st - stBegin);
+#endif
 
     if (st == stEnd)
     {
-        // printf("  got %d\n", st);
         uchar4 a;
         a.x = level.workRect.x;
         a.y = level.workRect.y;
@@ -200,18 +261,14 @@ void __device icf::Cascade::detectAt(const uchar* __restrict__ hogluv, const int
     }
 }
 
-void icf::Cascade::detect(const cv::gpu::PtrStepSzb& hogluv, PtrStepSz<uchar4> objects,
-                          cudaStream_t stream) const
+void icf::Cascade::detect(const cv::gpu::PtrStepSzi& hogluv, PtrStepSz<uchar4> objects, cudaStream_t stream) const
 {
-    // detection kernel
     dim3 block(32, 8, 1);
-    // dim3 grid(32 * ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 1);
     dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 1);
-    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(ushort), objects);
+    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(int), objects);
     cudaSafeCall( cudaGetLastError() );
     if (!stream)
         cudaSafeCall( cudaDeviceSynchronize() );
-
 }
 
 }}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index a8ce8d483..7d4b65980 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -102,8 +102,8 @@ struct Cascade
         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
 
-    void detect(const cv::gpu::PtrStepSzb& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
-    void __device detectAt(const uchar* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
+    void detect(const cv::gpu::PtrStepSzi& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
+    void __device detectAt(const int* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
     float __device rescale(const icf::Level& level, uchar4& scaledRect,
                            const int channel, const float threshold) const;
 
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index abcae73dc..7e1a5abb9 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -381,6 +381,9 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octav
         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
+        // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+        //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
+
         // std::cout << "level " << sc
         //           << " octeve "
         //           << vlevels[sc].octave
@@ -421,6 +424,15 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     return true;
 }
 
+namespace {
+    char *itoa(long i, char* s, int /*dummy_radix*/)
+    {
+        sprintf(s, "%ld", i);
+        return s;
+    }
+}
+
+#define USE_REFERENCE_VALUES
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
                                 GpuMat& objects, const int /*rejectfactor*/, Stream s)
 {
@@ -431,14 +443,26 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     CV_Assert(colored.cols == 640 && colored.rows == 480);
 
     Filds& flds = *filds;
+
+#if defined USE_REFERENCE_VALUES
+    cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
+    cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
+    char buff[33];
+
+    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+    {
+        cv::Mat channel;
+        imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
+        GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
+#else
     GpuMat& dmem = flds.dmem;
     cudaMemset(dmem.data, 0, dmem.step * dmem.rows);
     GpuMat& shrunk = flds.shrunk;
     int w = shrunk.cols;
     int h = colored.rows / flds.storage.shrinkage;
 
-    cudaStream_t stream = StreamAccessor::getStream(s);
-
     std::vector<GpuMat> splited;
     for(int i = 0; i < 3; ++i)
     {
@@ -468,9 +492,6 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 
     GpuMat plane(dmem, cv::Rect(0, 0, colored.cols, colored.rows * Filds::HOG_LUV_BINS));
     cv::gpu::resize(plane, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-    // cv::Mat cpu(plane);
-    // cv::imshow("channels", cpu);
-    // cv::waitKey(0);
 
     // fer debug purpose
     // cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
@@ -482,6 +503,9 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
         cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
     }
 
+#endif
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
     // detection
     flds.detect(objects, stream);
 

From 4881205baee2807aeb9fe5e70551290474e80671 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Tue, 25 Sep 2012 22:43:43 +0400
Subject: [PATCH 020/155] refactor logs

---
 modules/gpu/src/cuda/isf-sc.cu | 82 ++++++++++++++--------------------
 1 file changed, 34 insertions(+), 48 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 6572c54fc..ccc1ddf30 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -47,6 +47,13 @@
 
 //#define LOG_CUDA_CASCADE
 
+#if defined LOG_CUDA_CASCADE
+# define dprintf(format, ...) \
+            do { printf(format, __VA_ARGS__); } while (0)
+#else
+# define dprintf(format, ...)
+#endif
+
 namespace cv { namespace gpu { namespace device {
 
 namespace icf {
@@ -98,10 +105,8 @@ __global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restric
 float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
                                      const int channel, const float threshold) const
 {
-#if defined LOG_CUDA_CASCADE
-    printf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
-    printf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
-#endif
+    dprintf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
+    dprintf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
 
     float relScale = level.relScale;
     float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
@@ -122,19 +127,15 @@ float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect
         approx = expected_new_area / sarea;
     }
 
-#if defined LOG_CUDA_CASCADE
-    printf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
+    dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
-#endif
 
     // compensation areas rounding
     float rootThreshold = threshold / approx;
     // printf("    approx %f\n", rootThreshold);
     rootThreshold *= level.scaling[(int)(channel > 6)];
 
-#if defined LOG_CUDA_CASCADE
-    printf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
-#endif
+    dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
 
     return rootThreshold;
 }
@@ -143,14 +144,12 @@ typedef unsigned char uchar;
 float __device get(const int* __restrict__ hogluv, const int pitch,
                    const int x, const int y, int channel, uchar4 area)
 {
-#if defined LOG_CUDA_CASCADE
-    printf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
-    printf("get for channel %d\n", channel);
-    printf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
+    dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
+    dprintf("get for channel %d\n", channel);
+    dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
         x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
         x + area.x, y + area.w);
-    printf("at point %d %d with offset %d\n", x, y, 0);
-#endif
+    dprintf("at point %d %d with offset %d\n", x, y, 0);
 
     const int* curr = hogluv + ((channel * 121) + y) * pitch;
 
@@ -159,9 +158,7 @@ float __device get(const int* __restrict__ hogluv, const int pitch,
     int c = curr[area.w * pitch + x + area.z];
     int d = curr[area.w * pitch + x + area.x];
 
-#if defined LOG_CUDA_CASCADE
-    printf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
-#endif
+    dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
 
     return (a - b + c - d);
 }
@@ -176,13 +173,11 @@ void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int p
     const int x = blockIdx.x * blockDim.x + threadIdx.x;
     // if (x > 0 || y > 0) return;
 
-    Level level = lls[0];
+    Level level = lls[blockIdx.z];
     if (x >= level.workRect.x || y >= level.workRect.y) return;
 
-#if defined LOG_CUDA_CASCADE
-    printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+    dprintf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
         level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
-#endif
 
     const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
     // printf("Octave: %d %d %d (%d %d) %f\n", octave.index, octave.stages,
@@ -196,17 +191,15 @@ void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int p
     for(; st < stEnd; ++st)
     {
         const float stage = stages(0, st);
-#if defined LOG_CUDA_CASCADE
-        printf("Stage: %f\n", stage);
-#endif
+        dprintf("Stage: %f\n", stage);
         {
             const int nId = st * 3;
 
             // work with root node
             const Node node = ((const Node*)nodes.ptr())[nId];
-#if defined LOG_CUDA_CASCADE
-            printf("Node: %d %f\n", node.feature, node.threshold);
-#endif
+
+            dprintf("Node: %d %f\n", node.feature, node.threshold);
+
             const Feature feature = ((const Feature*)features.ptr())[node.feature];
 
             uchar4 scaledRect = feature.rect;
@@ -214,14 +207,12 @@ void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int p
 
             float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
 
-#if defined LOG_CUDA_CASCADE
-            printf("root feature %d %f\n",feature.channel, sum);
-#endif
+            dprintf("root feature %d %f\n",feature.channel, sum);
+
             int next = 1 + (int)(sum >= threshold);
 
-#if defined LOG_CUDA_CASCADE
-            printf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
-#endif
+            dprintf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
+
             // leaves
             const Node leaf = ((const Node*)nodes.ptr())[nId + next];
             const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
@@ -235,22 +226,17 @@ void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int p
 
             detectionScore += impact;
 
-#if defined LOG_CUDA_CASCADE
-            printf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-            printf("extracted stage:\n");
-            printf("ct %f\n", stage);
-            printf("computed score %f\n\n", detectionScore);
-            printf("\n\n");
-#endif
-
+            dprintf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+            dprintf("extracted stage:\n");
+            dprintf("ct %f\n", stage);
+            dprintf("computed score %f\n\n", detectionScore);
+            dprintf("\n\n");
         }
 
-        if (detectionScore <= stage) break;
+        if (detectionScore <= stage || st - stBegin == 100) break;
     }
 
-#if defined LOG_CUDA_CASCADE
-    // printf("x %d y %d: %d\n", x, y, st - stBegin);
-#endif
+    dprintf("x %d y %d: %d\n", x, y, st - stBegin);
 
     if (st == stEnd)
     {
@@ -264,7 +250,7 @@ void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int p
 void icf::Cascade::detect(const cv::gpu::PtrStepSzi& hogluv, PtrStepSz<uchar4> objects, cudaStream_t stream) const
 {
     dim3 block(32, 8, 1);
-    dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 1);
+    dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 47);
     device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(int), objects);
     cudaSafeCall( cudaGetLastError() );
     if (!stream)

From 1917366528d0703b7646de10931a01490bb32b4f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 26 Sep 2012 11:18:09 +0400
Subject: [PATCH 021/155] empty cascade

---
 modules/gpu/src/cuda/isf-sc.cu  | 326 +++++++--------
 modules/gpu/src/icf.hpp         | 192 ++++-----
 modules/gpu/src/softcascade.cpp | 678 ++++++++++++++++----------------
 3 files changed, 596 insertions(+), 600 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index ccc1ddf30..33b2222c7 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -40,221 +40,221 @@
 //
 //M*/
 
-#include <icf.hpp>
-#include <opencv2/gpu/device/saturate_cast.hpp>
-#include <stdio.h>
-#include <float.h>
+// #include <icf.hpp>
+// #include <opencv2/gpu/device/saturate_cast.hpp>
+// #include <stdio.h>
+// #include <float.h>
 
-//#define LOG_CUDA_CASCADE
+// //#define LOG_CUDA_CASCADE
 
-#if defined LOG_CUDA_CASCADE
-# define dprintf(format, ...) \
-            do { printf(format, __VA_ARGS__); } while (0)
-#else
-# define dprintf(format, ...)
-#endif
+// #if defined LOG_CUDA_CASCADE
+// # define dprintf(format, ...) \
+//             do { printf(format, __VA_ARGS__); } while (0)
+// #else
+// # define dprintf(format, ...)
+// #endif
 
-namespace cv { namespace gpu { namespace device {
+// namespace cv { namespace gpu { namespace device {
 
-namespace icf {
+// namespace icf {
 
-    enum {
-        HOG_BINS = 6,
-        HOG_LUV_BINS = 10,
-        WIDTH = 640,
-        HEIGHT = 480,
-        GREY_OFFSET = HEIGHT * HOG_LUV_BINS
-    };
+//     enum {
+//         HOG_BINS = 6,
+//         HOG_LUV_BINS = 10,
+//         WIDTH = 640,
+//         HEIGHT = 480,
+//         GREY_OFFSET = HEIGHT * HOG_LUV_BINS
+//     };
 
-    __global__ void magToHist(const uchar* __restrict__ mag,
-                              const float* __restrict__ angle, const int angPitch,
-                                    uchar* __restrict__ hog,   const int hogPitch)
-    {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+//     __global__ void magToHist(const uchar* __restrict__ mag,
+//                               const float* __restrict__ angle, const int angPitch,
+//                                     uchar* __restrict__ hog,   const int hogPitch)
+//     {
+//         const int y = blockIdx.y * blockDim.y + threadIdx.y;
+//         const int x = blockIdx.x * blockDim.x + threadIdx.x;
 
-        const int bin = (int)(angle[y * angPitch + x]);
-        const uchar val = mag[y * angPitch + x];
+//         const int bin = (int)(angle[y * angPitch + x]);
+//         const uchar val = mag[y * angPitch + x];
 
-        hog[((HEIGHT * bin) + y) * hogPitch + x] = val;
-    }
+//         hog[((HEIGHT * bin) + y) * hogPitch + x] = val;
+//     }
 
-    void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle)
-    {
-        const uchar* mag = (const uchar*)hogluv.ptr(HEIGHT * HOG_BINS);
-        uchar* hog = (uchar*)hogluv.ptr();
-        const float* angle = (const float*)nangle.ptr();
+//     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle)
+//     {
+//         const uchar* mag = (const uchar*)hogluv.ptr(HEIGHT * HOG_BINS);
+//         uchar* hog = (uchar*)hogluv.ptr();
+//         const float* angle = (const float*)nangle.ptr();
 
-        dim3 block(32, 8);
-        dim3 grid(WIDTH / 32, HEIGHT / 8);
+//         dim3 block(32, 8);
+//         dim3 grid(WIDTH / 32, HEIGHT / 8);
 
-        magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step);
-        cudaSafeCall( cudaGetLastError() );
-        cudaSafeCall( cudaDeviceSynchronize() );
-    }
-}
+//         magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step);
+//         cudaSafeCall( cudaGetLastError() );
+//         cudaSafeCall( cudaDeviceSynchronize() );
+//     }
+// }
 
-__global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restrict__ hogluv, const int pitch,
-    PtrStepSz<uchar4> objects)
-{
-    cascade.detectAt(hogluv, pitch, objects);
-}
+// __global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restrict__ hogluv, const int pitch,
+//     PtrStepSz<uchar4> objects)
+// {
+//     cascade.detectAt(hogluv, pitch, objects);
+// }
 
-}
+// }
 
-float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
-                                     const int channel, const float threshold) const
-{
-    dprintf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
-    dprintf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
+// float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
+//                                      const int channel, const float threshold) const
+// {
+//     dprintf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
+//     dprintf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
 
-    float relScale = level.relScale;
-    float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
+//     float relScale = level.relScale;
+//     float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
-    // rescale
-    scaledRect.x = __float2int_rn(relScale * scaledRect.x);
-    scaledRect.y = __float2int_rn(relScale * scaledRect.y);
-    scaledRect.z = __float2int_rn(relScale * scaledRect.z);
-    scaledRect.w = __float2int_rn(relScale * scaledRect.w);
+//     // rescale
+//     scaledRect.x = __float2int_rn(relScale * scaledRect.x);
+//     scaledRect.y = __float2int_rn(relScale * scaledRect.y);
+//     scaledRect.z = __float2int_rn(relScale * scaledRect.z);
+//     scaledRect.w = __float2int_rn(relScale * scaledRect.w);
 
-    float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
+//     float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
 
-    float approx = 1.f;
-    if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
-    {
-        const float expected_new_area = farea * relScale * relScale;
-        approx = expected_new_area / sarea;
-    }
+//     float approx = 1.f;
+//     if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
+//     {
+//         const float expected_new_area = farea * relScale * relScale;
+//         approx = expected_new_area / sarea;
+//     }
 
-    dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
-        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
+//     dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
+//         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
 
-    // compensation areas rounding
-    float rootThreshold = threshold / approx;
-    // printf("    approx %f\n", rootThreshold);
-    rootThreshold *= level.scaling[(int)(channel > 6)];
+//     // compensation areas rounding
+//     float rootThreshold = threshold / approx;
+//     // printf("    approx %f\n", rootThreshold);
+//     rootThreshold *= level.scaling[(int)(channel > 6)];
 
-    dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
+//     dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
 
-    return rootThreshold;
-}
+//     return rootThreshold;
+// }
 
-typedef unsigned char uchar;
-float __device get(const int* __restrict__ hogluv, const int pitch,
-                   const int x, const int y, int channel, uchar4 area)
-{
-    dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
-    dprintf("get for channel %d\n", channel);
-    dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
-        x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
-        x + area.x, y + area.w);
-    dprintf("at point %d %d with offset %d\n", x, y, 0);
+// typedef unsigned char uchar;
+// float __device get(const int* __restrict__ hogluv, const int pitch,
+//                    const int x, const int y, int channel, uchar4 area)
+// {
+//     dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
+//     dprintf("get for channel %d\n", channel);
+//     dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
+//         x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
+//         x + area.x, y + area.w);
+//     dprintf("at point %d %d with offset %d\n", x, y, 0);
 
-    const int* curr = hogluv + ((channel * 121) + y) * pitch;
+//     const int* curr = hogluv + ((channel * 121) + y) * pitch;
 
-    int a = curr[area.y * pitch + x + area.x];
-    int b = curr[area.y * pitch + x + area.z];
-    int c = curr[area.w * pitch + x + area.z];
-    int d = curr[area.w * pitch + x + area.x];
+//     int a = curr[area.y * pitch + x + area.x];
+//     int b = curr[area.y * pitch + x + area.z];
+//     int c = curr[area.w * pitch + x + area.z];
+//     int d = curr[area.w * pitch + x + area.x];
 
-    dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
+//     dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
 
-    return (a - b + c - d);
-}
+//     return (a - b + c - d);
+// }
 
 
-void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int pitch,
-                                    PtrStepSz<uchar4>& objects) const
-{
-    const icf::Level* lls = (const icf::Level*)levels.ptr();
+// void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int pitch,
+//                                     PtrStepSz<uchar4>& objects) const
+// {
+//     const icf::Level* lls = (const icf::Level*)levels.ptr();
 
-    const int y = blockIdx.y * blockDim.y + threadIdx.y;
-    const int x = blockIdx.x * blockDim.x + threadIdx.x;
-    // if (x > 0 || y > 0) return;
+//     const int y = blockIdx.y * blockDim.y + threadIdx.y;
+//     const int x = blockIdx.x * blockDim.x + threadIdx.x;
+//     // if (x > 0 || y > 0) return;
 
-    Level level = lls[blockIdx.z];
-    if (x >= level.workRect.x || y >= level.workRect.y) return;
+//     Level level = lls[blockIdx.z];
+//     if (x >= level.workRect.x || y >= level.workRect.y) return;
 
-    dprintf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-        level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
+//     dprintf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+//         level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
 
-    const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
-    // printf("Octave: %d %d %d (%d %d) %f\n", octave.index, octave.stages,
-    //     octave.shrinkage, octave.size.x, octave.size.y, octave.scale);
+//     const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
+//     // printf("Octave: %d %d %d (%d %d) %f\n", octave.index, octave.stages,
+//     //     octave.shrinkage, octave.size.x, octave.size.y, octave.scale);
 
-    const int stBegin = octave.index * octave.stages, stEnd = stBegin + octave.stages;
+//     const int stBegin = octave.index * octave.stages, stEnd = stBegin + octave.stages;
 
-    float detectionScore = 0.f;
+//     float detectionScore = 0.f;
 
-    int st = stBegin;
-    for(; st < stEnd; ++st)
-    {
-        const float stage = stages(0, st);
-        dprintf("Stage: %f\n", stage);
-        {
-            const int nId = st * 3;
+//     int st = stBegin;
+//     for(; st < stEnd; ++st)
+//     {
+//         const float stage = stages(0, st);
+//         dprintf("Stage: %f\n", stage);
+//         {
+//             const int nId = st * 3;
 
-            // work with root node
-            const Node node = ((const Node*)nodes.ptr())[nId];
+//             // work with root node
+//             const Node node = ((const Node*)nodes.ptr())[nId];
 
-            dprintf("Node: %d %f\n", node.feature, node.threshold);
+//             dprintf("Node: %d %f\n", node.feature, node.threshold);
 
-            const Feature feature = ((const Feature*)features.ptr())[node.feature];
+//             const Feature feature = ((const Feature*)features.ptr())[node.feature];
 
-            uchar4 scaledRect = feature.rect;
-            float threshold = rescale(level, scaledRect, feature.channel, node.threshold);
+//             uchar4 scaledRect = feature.rect;
+//             float threshold = rescale(level, scaledRect, feature.channel, node.threshold);
 
-            float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
+//             float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
 
-            dprintf("root feature %d %f\n",feature.channel, sum);
+//             dprintf("root feature %d %f\n",feature.channel, sum);
 
-            int next = 1 + (int)(sum >= threshold);
+//             int next = 1 + (int)(sum >= threshold);
 
-            dprintf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
+//             dprintf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
 
-            // leaves
-            const Node leaf = ((const Node*)nodes.ptr())[nId + next];
-            const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
+//             // leaves
+//             const Node leaf = ((const Node*)nodes.ptr())[nId + next];
+//             const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
 
-            scaledRect = fLeaf.rect;
-            threshold = rescale(level, scaledRect, fLeaf.channel, leaf.threshold);
-            sum = get(hogluv, pitch, x, y, fLeaf.channel, scaledRect);
+//             scaledRect = fLeaf.rect;
+//             threshold = rescale(level, scaledRect, fLeaf.channel, leaf.threshold);
+//             sum = get(hogluv, pitch, x, y, fLeaf.channel, scaledRect);
 
-            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-            float impact = leaves(0, (st * 4) + lShift);
+//             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+//             float impact = leaves(0, (st * 4) + lShift);
 
-            detectionScore += impact;
+//             detectionScore += impact;
 
-            dprintf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-            dprintf("extracted stage:\n");
-            dprintf("ct %f\n", stage);
-            dprintf("computed score %f\n\n", detectionScore);
-            dprintf("\n\n");
-        }
+//             dprintf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+//             dprintf("extracted stage:\n");
+//             dprintf("ct %f\n", stage);
+//             dprintf("computed score %f\n\n", detectionScore);
+//             dprintf("\n\n");
+//         }
 
-        if (detectionScore <= stage || st - stBegin == 100) break;
-    }
+//         if (detectionScore <= stage || st - stBegin == 100) break;
+//     }
 
-    dprintf("x %d y %d: %d\n", x, y, st - stBegin);
+//     dprintf("x %d y %d: %d\n", x, y, st - stBegin);
 
-    if (st == stEnd)
-    {
-        uchar4 a;
-        a.x = level.workRect.x;
-        a.y = level.workRect.y;
-        objects(0, threadIdx.x) = a;
-    }
-}
+//     if (st == stEnd)
+//     {
+//         uchar4 a;
+//         a.x = level.workRect.x;
+//         a.y = level.workRect.y;
+//         objects(0, threadIdx.x) = a;
+//     }
+// }
 
-void icf::Cascade::detect(const cv::gpu::PtrStepSzi& hogluv, PtrStepSz<uchar4> objects, cudaStream_t stream) const
-{
-    dim3 block(32, 8, 1);
-    dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 47);
-    device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(int), objects);
-    cudaSafeCall( cudaGetLastError() );
-    if (!stream)
-        cudaSafeCall( cudaDeviceSynchronize() );
-}
+// void icf::Cascade::detect(const cv::gpu::PtrStepSzi& hogluv, PtrStepSz<uchar4> objects, cudaStream_t stream) const
+// {
+//     dim3 block(32, 8, 1);
+//     dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 47);
+//     device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(int), objects);
+//     cudaSafeCall( cudaGetLastError() );
+//     if (!stream)
+//         cudaSafeCall( cudaDeviceSynchronize() );
+// }
 
-}}
\ No newline at end of file
+// }}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 7d4b65980..cf1348007 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -40,127 +40,127 @@
 //
 //M*/
 
-#include <opencv2/gpu/device/common.hpp>
+// #include <opencv2/gpu/device/common.hpp>
 
-#ifndef __OPENCV_ICF_HPP__
-#define __OPENCV_ICF_HPP__
+// #ifndef __OPENCV_ICF_HPP__
+// #define __OPENCV_ICF_HPP__
 
-#if defined __CUDACC__
-# define __device __device__ __forceinline__
-#else
-# define __device
-#endif
+// #if defined __CUDACC__
+// # define __device __device__ __forceinline__
+// #else
+// # define __device
+// #endif
 
 
-namespace cv { namespace gpu { namespace icf {
+// namespace cv { namespace gpu { namespace icf {
 
-using cv::gpu::PtrStepSzb;
-using cv::gpu::PtrStepSzf;
+// using cv::gpu::PtrStepSzb;
+// using cv::gpu::PtrStepSzf;
 
-typedef unsigned char uchar;
+// typedef unsigned char uchar;
 
-struct __align__(16) Octave
-{
-    ushort index;
-    ushort stages;
-    ushort shrinkage;
-    ushort2 size;
-    float scale;
+// struct __align__(16) Octave
+// {
+//     ushort index;
+//     ushort stages;
+//     ushort shrinkage;
+//     ushort2 size;
+//     float scale;
 
-    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
-    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
-};
+//     Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+//     : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+// };
 
-struct __align__(8) Level //is actually 24 bytes
-{
-    int octave;
+// struct __align__(8) Level //is actually 24 bytes
+// {
+//     int octave;
 
-    // float origScale; //not actually used
-    float relScale;
-    float shrScale;   // used for marking detection
-    float scaling[2]; // calculated according to Dollal paper
+//     // float origScale; //not actually used
+//     float relScale;
+//     float shrScale;   // used for marking detection
+//     float scaling[2]; // calculated according to Dollal paper
 
-    // for 640x480 we can not get overflow
-    uchar2 workRect;
-    uchar2 objSize;
+//     // for 640x480 we can not get overflow
+//     uchar2 workRect;
+//     uchar2 objSize;
 
-    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-    {
-        workRect.x = round(w / (float)oct.shrinkage);
-        workRect.y = round(h / (float)oct.shrinkage);
+//     Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+//     :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+//     {
+//         workRect.x = round(w / (float)oct.shrinkage);
+//         workRect.y = round(h / (float)oct.shrinkage);
 
-        objSize.x  = round(oct.size.x * relScale);
-        objSize.y  = round(oct.size.y * relScale);
-    }
-};
+//         objSize.x  = round(oct.size.x * relScale);
+//         objSize.y  = round(oct.size.y * relScale);
+//     }
+// };
 
-struct Cascade
-{
-    Cascade() {}
-    Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
-        const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
-    : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
+// struct Cascade
+// {
+//     Cascade() {}
+//     Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
+//         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
+//     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
 
-    void detect(const cv::gpu::PtrStepSzi& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
-    void __device detectAt(const int* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
-    float __device rescale(const icf::Level& level, uchar4& scaledRect,
-                           const int channel, const float threshold) const;
+//     void detect(const cv::gpu::PtrStepSzi& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
+//     void __device detectAt(const int* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
+//     float __device rescale(const icf::Level& level, uchar4& scaledRect,
+//                            const int channel, const float threshold) const;
 
-    PtrStepSzb octaves;
-    PtrStepSzf stages;
-    PtrStepSzb nodes;
-    PtrStepSzf leaves;
-    PtrStepSzb features;
+//     PtrStepSzb octaves;
+//     PtrStepSzf stages;
+//     PtrStepSzb nodes;
+//     PtrStepSzf leaves;
+//     PtrStepSzb features;
 
-    PtrStepSzb levels;
+//     PtrStepSzb levels;
 
-};
+// };
 
-struct ChannelStorage
-{
-    ChannelStorage(){}
-    ChannelStorage(const cv::gpu::PtrStepSzb& buff, const cv::gpu::PtrStepSzb& shr,
-        const cv::gpu::PtrStepSzb& itg, const int s)
-    : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
+// struct ChannelStorage
+// {
+//     ChannelStorage(){}
+//     ChannelStorage(const cv::gpu::PtrStepSzb& buff, const cv::gpu::PtrStepSzb& shr,
+//         const cv::gpu::PtrStepSzb& itg, const int s)
+//     : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
 
-    void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream){}
+//     void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream){}
 
-    PtrStepSzb dmem;
-    PtrStepSzb shrunk;
-    PtrStepSzb hogluv;
+//     PtrStepSzb dmem;
+//     PtrStepSzb shrunk;
+//     PtrStepSzb hogluv;
 
-    enum
-    {
-        FRAME_WIDTH        = 640,
-        FRAME_HEIGHT       = 480,
-        TOTAL_SCALES       = 55,
-        CLASSIFIERS        = 5,
-        ORIG_OBJECT_WIDTH  = 64,
-        ORIG_OBJECT_HEIGHT = 128,
-        HOG_BINS           = 6,
-        HOG_LUV_BINS       = 10
-    };
+//     enum
+//     {
+//         FRAME_WIDTH        = 640,
+//         FRAME_HEIGHT       = 480,
+//         TOTAL_SCALES       = 55,
+//         CLASSIFIERS        = 5,
+//         ORIG_OBJECT_WIDTH  = 64,
+//         ORIG_OBJECT_HEIGHT = 128,
+//         HOG_BINS           = 6,
+//         HOG_LUV_BINS       = 10
+//     };
 
-    int shrinkage;
-    static const float magnitudeScaling = 1.f ;// / sqrt(2);
-};
+//     int shrinkage;
+//     static const float magnitudeScaling = 1.f ;// / sqrt(2);
+// };
 
-struct __align__(8) Node
-{
-    int feature;
-    float threshold;
+// struct __align__(8) Node
+// {
+//     int feature;
+//     float threshold;
 
-    Node(const int f, const float t) : feature(f), threshold(t) {}
-};
+//     Node(const int f, const float t) : feature(f), threshold(t) {}
+// };
 
-struct __align__(8) Feature
-{
-    int channel;
-    uchar4 rect;
+// struct __align__(8) Feature
+// {
+//     int channel;
+//     uchar4 rect;
 
-    Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-};
-}}}
+//     Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+// };
+// }}}
 
-#endif
\ No newline at end of file
+// #endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 7e1a5abb9..c4334ca1d 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -41,361 +41,365 @@
 //M*/
 
 #include <precomp.hpp>
-#include "opencv2/highgui/highgui.hpp"
+#include <opencv2/highgui/highgui.hpp>
 
 #if !defined (HAVE_CUDA)
 
 cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
-
 cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
-
 cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
-
-bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); }
-
+bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); return false; }
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, Stream) { throw_nogpu(); }
 
 #else
 
-#include <icf.hpp>
+// #include <icf.hpp>
 
-namespace cv { namespace gpu { namespace device {
-namespace icf {
-    void fillBins(cv::gpu::PtrStepSzb hogluv,const cv::gpu::PtrStepSzf& nangle);
-}
-}}}
+// namespace cv { namespace gpu { namespace device {
+// namespace icf {
+//     void fillBins(cv::gpu::PtrStepSzb hogluv,const cv::gpu::PtrStepSzf& nangle);
+// }
+// }}}
+
+// namespace {
+//     char *itoa(long i, char* s, int /*dummy_radix*/)
+//     {
+//         sprintf(s, "%ld", i);
+//         return s;
+//     }
+// }
 
 struct cv::gpu::SoftCascade::Filds
 {
-    // scales range
-    float minScale;
-    float maxScale;
+//     // scales range
+//     float minScale;
+//     float maxScale;
 
-    int origObjWidth;
-    int origObjHeight;
+//     int origObjWidth;
+//     int origObjHeight;
 
-    GpuMat octaves;
-    GpuMat stages;
-    GpuMat nodes;
-    GpuMat leaves;
-    GpuMat features;
-    GpuMat levels;
+//     GpuMat octaves;
+//     GpuMat stages;
+//     GpuMat nodes;
+//     GpuMat leaves;
+//     GpuMat features;
+//     GpuMat levels;
 
-    // preallocated buffer 640x480x10 + 640x480
-    GpuMat dmem;
-    // 160x120x10
-    GpuMat shrunk;
-    // 161x121x10
-    GpuMat hogluv;
+//     // preallocated buffer 640x480x10 + 640x480
+//     GpuMat dmem;
+//     // 160x120x10
+//     GpuMat shrunk;
+//     // 161x121x10
+//     GpuMat hogluv;
 
-    // will be removed in final version
-    // temporial mat for cvtColor
-    GpuMat luv;
+//     // will be removed in final version
+//     // temporial mat for cvtColor
+//     GpuMat luv;
 
-    // temporial mat for integrall
-    GpuMat integralBuffer;
+//     // temporial mat for integrall
+//     GpuMat integralBuffer;
 
-    // temp matrix for sobel and cartToPolar
-    GpuMat dfdx, dfdy, angle, mag, nmag, nangle;
+//     // temp matrix for sobel and cartToPolar
+//     GpuMat dfdx, dfdy, angle, mag, nmag, nangle;
 
-    std::vector<float> scales;
+//     std::vector<float> scales;
 
-    icf::Cascade cascade;
-    icf::ChannelStorage storage;
+//     icf::Cascade cascade;
+//     icf::ChannelStorage storage;
 
-    enum { BOOST = 0 };
-    enum
-    {
-        FRAME_WIDTH        = 640,
-        FRAME_HEIGHT       = 480,
-        TOTAL_SCALES       = 55,
-        CLASSIFIERS        = 5,
-        ORIG_OBJECT_WIDTH  = 64,
-        ORIG_OBJECT_HEIGHT = 128,
-        HOG_BINS           = 6,
-        HOG_LUV_BINS       = 10
-    };
+//     enum { BOOST = 0 };
+//     enum
+//     {
+//         FRAME_WIDTH        = 640,
+//         FRAME_HEIGHT       = 480,
+//         TOTAL_SCALES       = 55,
+//         CLASSIFIERS        = 5,
+//         ORIG_OBJECT_WIDTH  = 64,
+//         ORIG_OBJECT_HEIGHT = 128,
+//         HOG_BINS           = 6,
+//         HOG_LUV_BINS       = 10
+//     };
 
-    bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
-    {
-        cascade.detect(hogluv, objects, stream);
-    }
+//     bool fill(const FileNode &root, const float mins, const float maxs);
+//     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
+//     {
+//         cascade.detect(hogluv, objects, stream);
+//     }
 
-private:
-    void calcLevels(const std::vector<icf::Octave>& octs,
-                                                    int frameW, int frameH, int nscales);
+// private:
+//     void calcLevels(const std::vector<icf::Octave>& octs,
+//                                                     int frameW, int frameH, int nscales);
 
-    typedef std::vector<icf::Octave>::const_iterator  octIt_t;
-    int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor) const
-    {
-        float minAbsLog = FLT_MAX;
-        int res =  0;
-        for (int oct = 0; oct < (int)octs.size(); ++oct)
-        {
-            const icf::Octave& octave =octs[oct];
-            float logOctave = ::log(octave.scale);
-            float logAbsScale = ::fabs(logFactor - logOctave);
+//     typedef std::vector<icf::Octave>::const_iterator  octIt_t;
+//     int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor) const
+//     {
+//         float minAbsLog = FLT_MAX;
+//         int res =  0;
+//         for (int oct = 0; oct < (int)octs.size(); ++oct)
+//         {
+//             const icf::Octave& octave =octs[oct];
+//             float logOctave = ::log(octave.scale);
+//             float logAbsScale = ::fabs(logFactor - logOctave);
 
-            if(logAbsScale < minAbsLog)
-            {
-                res = oct;
-                minAbsLog = logAbsScale;
-            }
-        }
-        return res;
-    }
+//             if(logAbsScale < minAbsLog)
+//             {
+//                 res = oct;
+//                 minAbsLog = logAbsScale;
+//             }
+//         }
+//         return res;
+//     }
 };
 
-inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
-{
-    minScale = mins;
-    maxScale = maxs;
+// inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
+// {
+//     minScale = mins;
+//     maxScale = maxs;
 
-    // cascade properties
-    static const char *const SC_STAGE_TYPE          = "stageType";
-    static const char *const SC_BOOST               = "BOOST";
+//     // cascade properties
+//     static const char *const SC_STAGE_TYPE          = "stageType";
+//     static const char *const SC_BOOST               = "BOOST";
 
-    static const char *const SC_FEATURE_TYPE        = "featureType";
-    static const char *const SC_ICF                 = "ICF";
+//     static const char *const SC_FEATURE_TYPE        = "featureType";
+//     static const char *const SC_ICF                 = "ICF";
 
-    static const char *const SC_ORIG_W              = "width";
-    static const char *const SC_ORIG_H              = "height";
+//     static const char *const SC_ORIG_W              = "width";
+//     static const char *const SC_ORIG_H              = "height";
 
-    static const char *const SC_OCTAVES             = "octaves";
-    static const char *const SC_STAGES              = "stages";
-    static const char *const SC_FEATURES            = "features";
+//     static const char *const SC_OCTAVES             = "octaves";
+//     static const char *const SC_STAGES              = "stages";
+//     static const char *const SC_FEATURES            = "features";
 
-    static const char *const SC_WEEK                = "weakClassifiers";
-    static const char *const SC_INTERNAL            = "internalNodes";
-    static const char *const SC_LEAF                = "leafValues";
+//     static const char *const SC_WEEK                = "weakClassifiers";
+//     static const char *const SC_INTERNAL            = "internalNodes";
+//     static const char *const SC_LEAF                = "leafValues";
 
-    static const char *const SC_OCT_SCALE           = "scale";
-    static const char *const SC_OCT_STAGES          = "stageNum";
-    static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
+//     static const char *const SC_OCT_SCALE           = "scale";
+//     static const char *const SC_OCT_STAGES          = "stageNum";
+//     static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
 
-    static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
+//     static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
 
-    static const char * const SC_F_CHANNEL          = "channel";
-    static const char * const SC_F_RECT             = "rect";
+//     static const char * const SC_F_CHANNEL          = "channel";
+//     static const char * const SC_F_RECT             = "rect";
 
-    // only Ada Boost supported
-    std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
-    CV_Assert(stageTypeStr == SC_BOOST);
+//     // only Ada Boost supported
+//     std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
+//     CV_Assert(stageTypeStr == SC_BOOST);
 
-    // only HOG-like integral channel features cupported
-    string featureTypeStr = (string)root[SC_FEATURE_TYPE];
-    CV_Assert(featureTypeStr == SC_ICF);
+//     // only HOG-like integral channel features cupported
+//     string featureTypeStr = (string)root[SC_FEATURE_TYPE];
+//     CV_Assert(featureTypeStr == SC_ICF);
 
-    origObjWidth = (int)root[SC_ORIG_W];
-    CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
+//     origObjWidth = (int)root[SC_ORIG_W];
+//     CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
 
-    origObjHeight = (int)root[SC_ORIG_H];
-    CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
+//     origObjHeight = (int)root[SC_ORIG_H];
+//     CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
 
-    FileNode fn = root[SC_OCTAVES];
-        if (fn.empty()) return false;
+//     FileNode fn = root[SC_OCTAVES];
+//         if (fn.empty()) return false;
 
-    std::vector<icf::Octave>  voctaves;
-    std::vector<float>        vstages;
-    std::vector<icf::Node>    vnodes;
-    std::vector<float>        vleaves;
-    std::vector<icf::Feature> vfeatures;
-    scales.clear();
+//     std::vector<icf::Octave>  voctaves;
+//     std::vector<float>        vstages;
+//     std::vector<icf::Node>    vnodes;
+//     std::vector<float>        vleaves;
+//     std::vector<icf::Feature> vfeatures;
+//     scales.clear();
 
-    // std::vector<Level> levels;
+//     // std::vector<Level> levels;
 
-    FileNodeIterator it = fn.begin(), it_end = fn.end();
-    int feature_offset = 0;
-    ushort octIndex = 0;
-    ushort shrinkage = 1;
+//     FileNodeIterator it = fn.begin(), it_end = fn.end();
+//     int feature_offset = 0;
+//     ushort octIndex = 0;
+//     ushort shrinkage = 1;
 
-    for (; it != it_end; ++it)
-    {
-        FileNode fns = *it;
-        float scale = (float)fns[SC_OCT_SCALE];
-        scales.push_back(scale);
-        ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
-        ushort2 size;
-        size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
-        size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
-        shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
+//     for (; it != it_end; ++it)
+//     {
+//         FileNode fns = *it;
+//         float scale = (float)fns[SC_OCT_SCALE];
+//         scales.push_back(scale);
+//         ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
+//         ushort2 size;
+//         size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
+//         size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
+//         shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
 
-        icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
-        CV_Assert(octave.stages > 0);
-        voctaves.push_back(octave);
+//         icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
+//         CV_Assert(octave.stages > 0);
+//         voctaves.push_back(octave);
 
-        FileNode ffs = fns[SC_FEATURES];
-        if (ffs.empty()) return false;
+//         FileNode ffs = fns[SC_FEATURES];
+//         if (ffs.empty()) return false;
 
-        fns = fns[SC_STAGES];
-        if (fn.empty()) return false;
+//         fns = fns[SC_STAGES];
+//         if (fn.empty()) return false;
 
-        // for each stage (~ decision tree with H = 2)
-        FileNodeIterator st = fns.begin(), st_end = fns.end();
-        for (; st != st_end; ++st )
-        {
-            fns = *st;
-            vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
+//         // for each stage (~ decision tree with H = 2)
+//         FileNodeIterator st = fns.begin(), st_end = fns.end();
+//         for (; st != st_end; ++st )
+//         {
+//             fns = *st;
+//             vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
 
-            fns = fns[SC_WEEK];
-            FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
-            for (; ftr != ft_end; ++ftr)
-            {
-                fns = (*ftr)[SC_INTERNAL];
-                FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
-                for (; inIt != inIt_end;)
-                {
-                    int feature = (int)(*(inIt +=2)++) + feature_offset;
-                    float th = (float)(*(inIt++));
-                    vnodes.push_back(icf::Node(feature, th));
-                }
+//             fns = fns[SC_WEEK];
+//             FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
+//             for (; ftr != ft_end; ++ftr)
+//             {
+//                 fns = (*ftr)[SC_INTERNAL];
+//                 FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
+//                 for (; inIt != inIt_end;)
+//                 {
+//                     int feature = (int)(*(inIt +=2)++) + feature_offset;
+//                     float th = (float)(*(inIt++));
+//                     vnodes.push_back(icf::Node(feature, th));
+//                 }
 
-                fns = (*ftr)[SC_LEAF];
-                inIt = fns.begin(), inIt_end = fns.end();
-                for (; inIt != inIt_end; ++inIt)
-                    vleaves.push_back((float)(*inIt));
-            }
-        }
+//                 fns = (*ftr)[SC_LEAF];
+//                 inIt = fns.begin(), inIt_end = fns.end();
+//                 for (; inIt != inIt_end; ++inIt)
+//                     vleaves.push_back((float)(*inIt));
+//             }
+//         }
 
-        st = ffs.begin(), st_end = ffs.end();
-        for (; st != st_end; ++st )
-        {
-            cv::FileNode rn = (*st)[SC_F_RECT];
-            cv::FileNodeIterator r_it = rn.begin();
-            uchar4 rect;
-            rect.x = saturate_cast<uchar>((int)*(r_it++));
-            rect.y = saturate_cast<uchar>((int)*(r_it++));
-            rect.z = saturate_cast<uchar>((int)*(r_it++));
-            rect.w = saturate_cast<uchar>((int)*(r_it++));
-            vfeatures.push_back(icf::Feature((int)(*st)[SC_F_CHANNEL], rect));
-        }
+//         st = ffs.begin(), st_end = ffs.end();
+//         for (; st != st_end; ++st )
+//         {
+//             cv::FileNode rn = (*st)[SC_F_RECT];
+//             cv::FileNodeIterator r_it = rn.begin();
+//             uchar4 rect;
+//             rect.x = saturate_cast<uchar>((int)*(r_it++));
+//             rect.y = saturate_cast<uchar>((int)*(r_it++));
+//             rect.z = saturate_cast<uchar>((int)*(r_it++));
+//             rect.w = saturate_cast<uchar>((int)*(r_it++));
+//             vfeatures.push_back(icf::Feature((int)(*st)[SC_F_CHANNEL], rect));
+//         }
 
-        feature_offset += octave.stages * 3;
-        ++octIndex;
-    }
+//         feature_offset += octave.stages * 3;
+//         ++octIndex;
+//     }
 
-    // upload in gpu memory
-    octaves.upload(cv::Mat(1, voctaves.size() * sizeof(icf::Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
-    CV_Assert(!octaves.empty());
+//     // upload in gpu memory
+//     octaves.upload(cv::Mat(1, voctaves.size() * sizeof(icf::Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
+//     CV_Assert(!octaves.empty());
 
-    stages.upload(cv::Mat(vstages).reshape(1,1));
-    CV_Assert(!stages.empty());
+//     stages.upload(cv::Mat(vstages).reshape(1,1));
+//     CV_Assert(!stages.empty());
 
-    nodes.upload(cv::Mat(1, vnodes.size() * sizeof(icf::Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
-    CV_Assert(!nodes.empty());
+//     nodes.upload(cv::Mat(1, vnodes.size() * sizeof(icf::Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
+//     CV_Assert(!nodes.empty());
 
-    leaves.upload(cv::Mat(vleaves).reshape(1,1));
-    CV_Assert(!leaves.empty());
+//     leaves.upload(cv::Mat(vleaves).reshape(1,1));
+//     CV_Assert(!leaves.empty());
 
-    features.upload(cv::Mat(1, vfeatures.size() * sizeof(icf::Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
-    CV_Assert(!features.empty());
+//     features.upload(cv::Mat(1, vfeatures.size() * sizeof(icf::Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
+//     CV_Assert(!features.empty());
 
-    // compute levels
-    calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
-    CV_Assert(!levels.empty());
+//     // compute levels
+//     calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
+//     CV_Assert(!levels.empty());
 
-    //init Cascade
-    cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
+//     //init Cascade
+//     cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
 
-    // allocate buffers
-    dmem.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
-    shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
-    // hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_16UC1);
-    hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_32SC1);
-    luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
-    integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
+//     // allocate buffers
+//     dmem.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
+//     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
+//     // hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_16UC1);
+//     hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_32SC1);
+//     luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
+//     integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
 
-    dfdx.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-    dfdy.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-    angle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-    mag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     dfdx.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     dfdy.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     angle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     mag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
 
-    nmag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-    nangle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     nmag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+//     nangle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
 
-    storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
-    return true;
-}
+//     storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
+//     return true;
+// }
 
-namespace {
-    struct CascadeIntrinsics
-    {
-        static const float lambda = 1.099f, a = 0.89f;
+// namespace {
+//     struct CascadeIntrinsics
+//     {
+//         static const float lambda = 1.099f, a = 0.89f;
 
-        static float getFor(int channel, float scaling)
-        {
-            CV_Assert(channel < 10);
+//         static float getFor(int channel, float scaling)
+//         {
+//             CV_Assert(channel < 10);
 
-            if (fabs(scaling - 1.f) < FLT_EPSILON)
-                return 1.f;
+//             if (fabs(scaling - 1.f) < FLT_EPSILON)
+//                 return 1.f;
 
-            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
-            static const float A[2][2] =
-            {   //channel <= 6, otherwise
-                {        0.89f, 1.f}, // down
-                {        1.00f, 1.f}  // up
-            };
+//             // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
+//             static const float A[2][2] =
+//             {   //channel <= 6, otherwise
+//                 {        0.89f, 1.f}, // down
+//                 {        1.00f, 1.f}  // up
+//             };
 
-            static const float B[2][2] =
-            {   //channel <= 6,  otherwise
-                { 1.099f / log(2), 2.f}, // down
-                {             0.f, 2.f}  // up
-            };
+//             static const float B[2][2] =
+//             {   //channel <= 6,  otherwise
+//                 { 1.099f / log(2), 2.f}, // down
+//                 {             0.f, 2.f}  // up
+//             };
 
-            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
-            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
+//             float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
+//             float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
 
-            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
-            return a * pow(scaling, b);
-        }
-    };
-}
+//             // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
+//             return a * pow(scaling, b);
+//         }
+//     };
+// }
 
-inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octave>& octs,
-                                                    int frameW, int frameH, int nscales)
-{
-    CV_Assert(nscales > 1);
+// inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octave>& octs,
+//                                                     int frameW, int frameH, int nscales)
+// {
+//     CV_Assert(nscales > 1);
 
-    std::vector<icf::Level> vlevels;
-    float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
+//     std::vector<icf::Level> vlevels;
+//     float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
 
-    float scale = minScale;
-    for (int sc = 0; sc < nscales; ++sc)
-    {
-        int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
-        int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
+//     float scale = minScale;
+//     for (int sc = 0; sc < nscales; ++sc)
+//     {
+//         int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
+//         int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
 
-        float logScale = ::log(scale);
-        int fit = fitOctave(octs, logScale);
+//         float logScale = ::log(scale);
+//         int fit = fitOctave(octs, logScale);
 
-        icf::Level level(fit, octs[fit], scale, width, height);
-        level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
-        level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
+//         icf::Level level(fit, octs[fit], scale, width, height);
+//         level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
+//         level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
 
-        if (!width || !height)
-            break;
-        else
-            vlevels.push_back(level);
+//         if (!width || !height)
+//             break;
+//         else
+//             vlevels.push_back(level);
 
-        if (::fabs(scale - maxScale) < FLT_EPSILON) break;
-        scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
+//         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
+//         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
-        // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-        //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
+//         // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+//         //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
 
-        // std::cout << "level " << sc
-        //           << " octeve "
-        //           << vlevels[sc].octave
-        //           << " relScale "
-        //           << vlevels[sc].relScale
-        //           << " " << vlevels[sc].shrScale
-        //           << " [" << (int)vlevels[sc].objSize.x
-        //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
-        // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
-    }
-    levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
-}
+//         // std::cout << "level " << sc
+//         //           << " octeve "
+//         //           << vlevels[sc].octave
+//         //           << " relScale "
+//         //           << vlevels[sc].relScale
+//         //           << " " << vlevels[sc].shrScale
+//         //           << " [" << (int)vlevels[sc].objSize.x
+//         //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
+//         // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
+//     }
+//     levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
+// }
 
 cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
 
@@ -419,97 +423,89 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     if (!fs.isOpened()) return false;
 
     filds = new Filds;
-    Filds& flds = *filds;
-    if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
+//     Filds& flds = *filds;
+//     if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
     return true;
 }
 
-namespace {
-    char *itoa(long i, char* s, int /*dummy_radix*/)
-    {
-        sprintf(s, "%ld", i);
-        return s;
-    }
-}
-
-#define USE_REFERENCE_VALUES
+// #define USE_REFERENCE_VALUES
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
                                 GpuMat& objects, const int /*rejectfactor*/, Stream s)
 {
-    // only color images are supperted
-    CV_Assert(colored.type() == CV_8UC3);
+//     // only color images are supperted
+//     CV_Assert(colored.type() == CV_8UC3);
 
-    // // only this window size allowed
-    CV_Assert(colored.cols == 640 && colored.rows == 480);
+//     // // only this window size allowed
+//     CV_Assert(colored.cols == 640 && colored.rows == 480);
 
-    Filds& flds = *filds;
+//     Filds& flds = *filds;
 
-#if defined USE_REFERENCE_VALUES
-    cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
-    cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
-    char buff[33];
+// #if defined USE_REFERENCE_VALUES
+//     cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
+//     cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
+//     char buff[33];
 
-    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-    {
-        cv::Mat channel;
-        imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
-        GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
-        gchannel.upload(channel);
-    }
-#else
-    GpuMat& dmem = flds.dmem;
-    cudaMemset(dmem.data, 0, dmem.step * dmem.rows);
-    GpuMat& shrunk = flds.shrunk;
-    int w = shrunk.cols;
-    int h = colored.rows / flds.storage.shrinkage;
+//     for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+//     {
+//         cv::Mat channel;
+//         imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
+//         GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
+//         gchannel.upload(channel);
+//     }
+// #else
+//     GpuMat& dmem = flds.dmem;
+//     cudaMemset(dmem.data, 0, dmem.step * dmem.rows);
+//     GpuMat& shrunk = flds.shrunk;
+//     int w = shrunk.cols;
+//     int h = colored.rows / flds.storage.shrinkage;
 
-    std::vector<GpuMat> splited;
-    for(int i = 0; i < 3; ++i)
-    {
-        splited.push_back(GpuMat(dmem, cv::Rect(0, colored.rows * (7 + i), colored.cols, colored.rows)));
-    }
+//     std::vector<GpuMat> splited;
+//     for(int i = 0; i < 3; ++i)
+//     {
+//         splited.push_back(GpuMat(dmem, cv::Rect(0, colored.rows * (7 + i), colored.cols, colored.rows)));
+//     }
 
-    GpuMat gray(dmem, cv::Rect(0, colored.rows * 10, colored.cols, colored.rows) );
+//     GpuMat gray(dmem, cv::Rect(0, colored.rows * 10, colored.cols, colored.rows) );
 
-    cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
+//     cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
 
-    //create hog
-    cv::gpu::Sobel(gray, flds.dfdx, CV_32F, 1, 0, 3, 0.25);
-    cv::gpu::Sobel(gray, flds.dfdy, CV_32F, 0, 1, 3, 0.25);
+//     //create hog
+//     cv::gpu::Sobel(gray, flds.dfdx, CV_32F, 1, 0, 3, 0.25);
+//     cv::gpu::Sobel(gray, flds.dfdy, CV_32F, 0, 1, 3, 0.25);
 
-    cv::gpu::cartToPolar(flds.dfdx, flds.dfdy, flds.mag, flds.angle, true);
+//     cv::gpu::cartToPolar(flds.dfdx, flds.dfdy, flds.mag, flds.angle, true);
 
-    cv::gpu::multiply(flds.mag, cv::Scalar::all(1.0 / ::log(2)), flds.nmag);
-    cv::gpu::multiply(flds.angle, cv::Scalar::all(1.0 / 60.0), flds.nangle);
+//     cv::gpu::multiply(flds.mag, cv::Scalar::all(1.0 / ::log(2)), flds.nmag);
+//     cv::gpu::multiply(flds.angle, cv::Scalar::all(1.0 / 60.0), flds.nangle);
 
-    GpuMat magCannel(dmem, cv::Rect(0, colored.rows * 6, colored.cols, colored.rows));
-    flds.nmag.convertTo(magCannel, CV_8UC1);
-    device::icf::fillBins(dmem, flds.nangle);
+//     GpuMat magCannel(dmem, cv::Rect(0, colored.rows * 6, colored.cols, colored.rows));
+//     flds.nmag.convertTo(magCannel, CV_8UC1);
+//     device::icf::fillBins(dmem, flds.nangle);
 
-    // create luv
-    cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
-    cv::gpu::split(flds.luv, splited);
+//     // create luv
+//     cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
+//     cv::gpu::split(flds.luv, splited);
 
-    GpuMat plane(dmem, cv::Rect(0, 0, colored.cols, colored.rows * Filds::HOG_LUV_BINS));
-    cv::gpu::resize(plane, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+//     GpuMat plane(dmem, cv::Rect(0, 0, colored.cols, colored.rows * Filds::HOG_LUV_BINS));
+//     cv::gpu::resize(plane, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
 
-    // fer debug purpose
-    // cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
+//     // fer debug purpose
+//     // cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
 
-    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-    {
-        GpuMat channel(shrunk, cv::Rect(0, h  * i, w, h ));
-        GpuMat sum(flds.hogluv, cv::Rect(0, (h + 1) * i, w + 1, h + 1));
-        cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
-    }
+//     for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+//     {
+//         GpuMat channel(shrunk, cv::Rect(0, h  * i, w, h ));
+//         GpuMat sum(flds.hogluv, cv::Rect(0, (h + 1) * i, w + 1, h + 1));
+//         cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
+    // }
 
-#endif
+// #endif
 
-    cudaStream_t stream = StreamAccessor::getStream(s);
-    // detection
-    flds.detect(objects, stream);
+//     cudaStream_t stream = StreamAccessor::getStream(s);
+//     // detection
+//     flds.detect(objects, stream);
 
-    // flds.storage.frame(colored, stream);
+//     // flds.storage.frame(colored, stream);
 }
 
 #endif
\ No newline at end of file

From 4d9c7c1012be346f64fb50d50fd52d6ecb16b07e Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 26 Sep 2012 13:34:21 +0400
Subject: [PATCH 022/155] preprocessing ~1.981 ms

---
 modules/gpu/src/cuda/isf-sc.cu  |  54 +++++-----
 modules/gpu/src/softcascade.cpp | 175 +++++++++++++++++++-------------
 2 files changed, 133 insertions(+), 96 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 33b2222c7..e4831e2e6 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -40,6 +40,7 @@
 //
 //M*/
 
+#include <opencv2/gpu/device/common.hpp>
 // #include <icf.hpp>
 // #include <opencv2/gpu/device/saturate_cast.hpp>
 // #include <stdio.h>
@@ -54,9 +55,8 @@
 // # define dprintf(format, ...)
 // #endif
 
-// namespace cv { namespace gpu { namespace device {
-
-// namespace icf {
+namespace cv { namespace gpu { namespace device {
+namespace icf {
 
 //     enum {
 //         HOG_BINS = 6,
@@ -66,33 +66,35 @@
 //         GREY_OFFSET = HEIGHT * HOG_LUV_BINS
 //     };
 
-//     __global__ void magToHist(const uchar* __restrict__ mag,
-//                               const float* __restrict__ angle, const int angPitch,
-//                                     uchar* __restrict__ hog,   const int hogPitch)
-//     {
-//         const int y = blockIdx.y * blockDim.y + threadIdx.y;
-//         const int x = blockIdx.x * blockDim.x + threadIdx.x;
+    // ToDo: use textures or ancached load instruction.
+    __global__ void magToHist(const uchar* __restrict__ mag,
+                              const float* __restrict__ angle, const int angPitch,
+                                    uchar* __restrict__ hog,   const int hogPitch, const int fh)
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
 
-//         const int bin = (int)(angle[y * angPitch + x]);
-//         const uchar val = mag[y * angPitch + x];
+        const int bin = (int)(angle[y * angPitch + x]);
+        const uchar val = mag[y * hogPitch + x];
+        hog[((fh * bin) + y) * hogPitch + x] = val;
+    }
 
-//         hog[((HEIGHT * bin) + y) * hogPitch + x] = val;
-//     }
+    void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
+                  const int fw,  const int fh, const int bins)
+    {
+        const uchar* mag = (const uchar*)hogluv.ptr(fh * bins);
+        uchar* hog = (uchar*)hogluv.ptr();
+        const float* angle = (const float*)nangle.ptr();
 
-//     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle)
-//     {
-//         const uchar* mag = (const uchar*)hogluv.ptr(HEIGHT * HOG_BINS);
-//         uchar* hog = (uchar*)hogluv.ptr();
-//         const float* angle = (const float*)nangle.ptr();
+        dim3 block(32, 8);
+        dim3 grid(fw / 32, fh / 8);
 
-//         dim3 block(32, 8);
-//         dim3 grid(WIDTH / 32, HEIGHT / 8);
-
-//         magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step);
-//         cudaSafeCall( cudaGetLastError() );
-//         cudaSafeCall( cudaDeviceSynchronize() );
-//     }
-// }
+        magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step, fh);
+        cudaSafeCall( cudaGetLastError() );
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+}}}
 
 // __global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restrict__ hogluv, const int pitch,
 //     PtrStepSz<uchar4> objects)
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index c4334ca1d..f336fd2d9 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -49,17 +49,18 @@ cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
 bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); return false; }
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, Stream) { throw_nogpu(); }
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, Stream) { throw_nogpu();}
 
 #else
 
 // #include <icf.hpp>
 
-// namespace cv { namespace gpu { namespace device {
-// namespace icf {
-//     void fillBins(cv::gpu::PtrStepSzb hogluv,const cv::gpu::PtrStepSzf& nangle);
-// }
-// }}}
+namespace cv { namespace gpu { namespace device {
+namespace icf {
+    void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
+        const int fw, const int fh, const int bins);
+}
+}}}
 
 // namespace {
 //     char *itoa(long i, char* s, int /*dummy_radix*/)
@@ -71,6 +72,16 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat
 
 struct cv::gpu::SoftCascade::Filds
 {
+
+    Filds()
+    {
+        plane.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
+        fplane.create(FRAME_HEIGHT * 6, FRAME_WIDTH, CV_32FC1);
+        luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
+        shrunk.create(FRAME_HEIGHT / 4 * HOG_LUV_BINS, FRAME_WIDTH / 4, CV_8UC1);
+        integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
+        hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 1, CV_32SC1);
+    }
 //     // scales range
 //     float minScale;
 //     float maxScale;
@@ -85,19 +96,26 @@ struct cv::gpu::SoftCascade::Filds
 //     GpuMat features;
 //     GpuMat levels;
 
-//     // preallocated buffer 640x480x10 + 640x480
-//     GpuMat dmem;
-//     // 160x120x10
-//     GpuMat shrunk;
-//     // 161x121x10
-//     GpuMat hogluv;
+    // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
+    GpuMat plane;
+
+    // preallocated buffer for floating point operations
+    GpuMat fplane;
+
+    // temporial mat for cvtColor
+    GpuMat luv;
+
+    // 160x120x10
+    GpuMat shrunk;
+
+    // temporial mat for integrall
+    GpuMat integralBuffer;
+
+    // 161x121x10
+    GpuMat hogluv;
 
 //     // will be removed in final version
-//     // temporial mat for cvtColor
-//     GpuMat luv;
 
-//     // temporial mat for integrall
-//     GpuMat integralBuffer;
 
 //     // temp matrix for sobel and cartToPolar
 //     GpuMat dfdx, dfdy, angle, mag, nmag, nangle;
@@ -108,17 +126,18 @@ struct cv::gpu::SoftCascade::Filds
 //     icf::ChannelStorage storage;
 
 //     enum { BOOST = 0 };
-//     enum
-//     {
-//         FRAME_WIDTH        = 640,
-//         FRAME_HEIGHT       = 480,
+    enum
+    {
+        FRAME_WIDTH        = 640,
+        FRAME_HEIGHT       = 480,
 //         TOTAL_SCALES       = 55,
 //         CLASSIFIERS        = 5,
 //         ORIG_OBJECT_WIDTH  = 64,
 //         ORIG_OBJECT_HEIGHT = 128,
-//         HOG_BINS           = 6,
-//         HOG_LUV_BINS       = 10
-//     };
+        HOG_BINS           = 6,
+        LUV_BINS           = 3,
+        HOG_LUV_BINS       = 10
+    };
 
 //     bool fill(const FileNode &root, const float mins, const float maxs);
 //     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
@@ -386,7 +405,8 @@ struct cv::gpu::SoftCascade::Filds
 //         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
 //         // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-//         //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
+//         //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x,
+//level.objSize.y);
 
 //         // std::cout << "level " << sc
 //         //           << " octeve "
@@ -423,8 +443,8 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     if (!fs.isOpened()) return false;
 
     filds = new Filds;
-//     Filds& flds = *filds;
-//     if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
+    Filds& flds = *filds;
+    // if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
     return true;
 }
 
@@ -432,15 +452,15 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
                                 GpuMat& objects, const int /*rejectfactor*/, Stream s)
 {
-//     // only color images are supperted
-//     CV_Assert(colored.type() == CV_8UC3);
+    // only color images are supperted
+    CV_Assert(colored.type() == CV_8UC3);
 
-//     // // only this window size allowed
-//     CV_Assert(colored.cols == 640 && colored.rows == 480);
+    // only this window size allowed
+    CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
 
-//     Filds& flds = *filds;
+    Filds& flds = *filds;
 
-// #if defined USE_REFERENCE_VALUES
+#if defined USE_REFERENCE_VALUES
 //     cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
 //     cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
 //     char buff[33];
@@ -452,57 +472,72 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 //         GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
 //         gchannel.upload(channel);
 //     }
-// #else
-//     GpuMat& dmem = flds.dmem;
-//     cudaMemset(dmem.data, 0, dmem.step * dmem.rows);
-//     GpuMat& shrunk = flds.shrunk;
-//     int w = shrunk.cols;
-//     int h = colored.rows / flds.storage.shrinkage;
+#else
+    GpuMat& plane = flds.plane;
+    GpuMat& shrunk = flds.shrunk;
+    cudaMemset(plane.data, 0, plane.step * plane.rows);
 
-//     std::vector<GpuMat> splited;
-//     for(int i = 0; i < 3; ++i)
-//     {
-//         splited.push_back(GpuMat(dmem, cv::Rect(0, colored.rows * (7 + i), colored.cols, colored.rows)));
-//     }
+    int fw = Filds::FRAME_WIDTH;
+    int fh = Filds::FRAME_HEIGHT;
 
-//     GpuMat gray(dmem, cv::Rect(0, colored.rows * 10, colored.cols, colored.rows) );
+    GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
 
-//     cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
+    //cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
+    cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
 
-//     //create hog
-//     cv::gpu::Sobel(gray, flds.dfdx, CV_32F, 1, 0, 3, 0.25);
-//     cv::gpu::Sobel(gray, flds.dfdy, CV_32F, 0, 1, 3, 0.25);
+    //create hog
+    GpuMat dfdx(flds.fplane, cv::Rect(0,  0, fw, fh));
+    GpuMat dfdy(flds.fplane, cv::Rect(0, fh, fw, fh));
 
-//     cv::gpu::cartToPolar(flds.dfdx, flds.dfdy, flds.mag, flds.angle, true);
+    cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
+    cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
 
-//     cv::gpu::multiply(flds.mag, cv::Scalar::all(1.0 / ::log(2)), flds.nmag);
-//     cv::gpu::multiply(flds.angle, cv::Scalar::all(1.0 / 60.0), flds.nangle);
+    GpuMat mag(flds.fplane, cv::Rect(0, 2 * fh, fw, fh));
+    GpuMat ang(flds.fplane, cv::Rect(0, 3 * fh, fw, fh));
 
-//     GpuMat magCannel(dmem, cv::Rect(0, colored.rows * 6, colored.cols, colored.rows));
-//     flds.nmag.convertTo(magCannel, CV_8UC1);
-//     device::icf::fillBins(dmem, flds.nangle);
+    cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
 
-//     // create luv
-//     cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
-//     cv::gpu::split(flds.luv, splited);
+    // normolize magnitude to uchar interval and angles to 6 bins
 
-//     GpuMat plane(dmem, cv::Rect(0, 0, colored.cols, colored.rows * Filds::HOG_LUV_BINS));
-//     cv::gpu::resize(plane, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+    GpuMat nmag(flds.fplane, cv::Rect(0, 4 * fh, fw, fh));
+    GpuMat nang(flds.fplane, cv::Rect(0, 5 * fh, fw, fh));
 
-//     // fer debug purpose
-//     // cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
+    cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
+    cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
 
-//     for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-//     {
-//         GpuMat channel(shrunk, cv::Rect(0, h  * i, w, h ));
-//         GpuMat sum(flds.hogluv, cv::Rect(0, (h + 1) * i, w + 1, h + 1));
-//         cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
-    // }
+    //create uchar magnitude
+    GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
+    nmag.convertTo(cmag, CV_8UC1);
 
-// #endif
+    // create luv
+    cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
 
-//     cudaStream_t stream = StreamAccessor::getStream(s);
-//     // detection
+    std::vector<GpuMat> splited;
+    for(int i = 0; i < Filds::LUV_BINS; ++i)
+    {
+        splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
+    }
+
+    cv::gpu::split(flds.luv, splited);
+
+    device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
+
+    GpuMat hogluv(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
+    cv::gpu::resize(hogluv, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+
+    fw /= 4;
+    fh /= 4;
+    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+    {
+        GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
+        GpuMat sum(flds.hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
+        cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
+    }
+
+#endif
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+    // detection
 //     flds.detect(objects, stream);
 
 //     // flds.storage.frame(colored, stream);

From b83d4add2ea096b3481a838f9e26a038d10a93d5 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 26 Sep 2012 17:15:17 +0400
Subject: [PATCH 023/155] memory optimization

---
 modules/gpu/src/cuda/isf-sc.cu  |  56 +++-
 modules/gpu/src/icf.hpp         | 106 ++++---
 modules/gpu/src/softcascade.cpp | 489 +++++++++++++++-----------------
 3 files changed, 339 insertions(+), 312 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index e4831e2e6..714bdfa44 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -41,9 +41,9 @@
 //M*/
 
 #include <opencv2/gpu/device/common.hpp>
-// #include <icf.hpp>
+#include <icf.hpp>
 // #include <opencv2/gpu/device/saturate_cast.hpp>
-// #include <stdio.h>
+#include <stdio.h>
 // #include <float.h>
 
 // //#define LOG_CUDA_CASCADE
@@ -93,6 +93,58 @@ namespace icf {
         cudaSafeCall( cudaGetLastError() );
         cudaSafeCall( cudaDeviceSynchronize() );
     }
+
+    texture<float2,  cudaTextureType1D, cudaReadModeElementType> tnode;
+    __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
+        const Node* nodes,
+        PtrStepSz<uchar4> objects)
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        Level level = levels[blockIdx.z];
+        if(x >= level.workRect.x || y >= level.workRect.y) return;
+
+        Octave octave = octaves[level.octave];
+        int st = octave.index * octave.stages;
+        const int stEnd = st + 1000;//octave.stages;
+
+        float confidence = 0.f;
+
+#pragma unroll 8
+        for(; st < stEnd; ++st)
+        {
+            const int nId = st * 3;
+            const Node node = nodes[nId];
+
+            const float stage = stages[st];
+            confidence += node.rect.x * stage;
+        }
+
+        uchar4 val;
+        val.x = (int)confidence;
+        if (x == y) objects(0, threadIdx.x) = val;
+
+    }
+
+    void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
+        const PtrStepSzb& nodes, const PtrStepSzb& features,
+        PtrStepSz<uchar4> objects)
+    {
+        int fw = 160;
+        int fh = 120;
+        dim3 block(32, 8);
+        dim3 grid(fw / 32, fh / 8, 47);
+        const Level* l = (const Level*)levels.ptr();
+        const Octave* oct = ((const Octave*)octaves.ptr());
+        const float* st = (const float*)stages.ptr();
+        const Node* nd = (const Node*)nodes.ptr();
+        // cudaSafeCall( cudaBindTexture(0, tnode, nodes.data, rgb.cols / size) );
+
+        test_kernel<<<grid, block>>>(l, oct, st, nd, objects);
+
+        cudaSafeCall( cudaGetLastError());
+        cudaSafeCall( cudaDeviceSynchronize());
+    }
 }
 }}}
 
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index cf1348007..51ea2c068 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -1,4 +1,4 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
+//M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
@@ -38,12 +38,12 @@
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
-//M*/
+//M
 
-// #include <opencv2/gpu/device/common.hpp>
+#include <opencv2/gpu/device/common.hpp>
 
-// #ifndef __OPENCV_ICF_HPP__
-// #define __OPENCV_ICF_HPP__
+#ifndef __OPENCV_ICF_HPP__
+#define __OPENCV_ICF_HPP__
 
 // #if defined __CUDACC__
 // # define __device __device__ __forceinline__
@@ -52,49 +52,62 @@
 // #endif
 
 
-// namespace cv { namespace gpu { namespace icf {
+namespace cv { namespace gpu { namespace device {
+namespace icf {
 
-// using cv::gpu::PtrStepSzb;
-// using cv::gpu::PtrStepSzf;
+struct __align__(16) Octave
+{
+    ushort index;
+    ushort stages;
+    ushort shrinkage;
+    ushort2 size;
+    float scale;
 
-// typedef unsigned char uchar;
+    Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
+    : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
+};
 
-// struct __align__(16) Octave
-// {
-//     ushort index;
-//     ushort stages;
-//     ushort shrinkage;
-//     ushort2 size;
-//     float scale;
+struct __align__(8) Level //is actually 24 bytes
+{
+    int octave;
 
-//     Octave(const ushort i, const ushort s, const ushort sh, const ushort2 sz, const float sc)
-//     : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
-// };
+    float relScale;
+    float shrScale;   // used for marking detection
+    float scaling[2]; // calculated according to Dollal paper
 
-// struct __align__(8) Level //is actually 24 bytes
-// {
-//     int octave;
+    // for 640x480 we can not get overflow
+    uchar2 workRect;
+    uchar2 objSize;
 
-//     // float origScale; //not actually used
-//     float relScale;
-//     float shrScale;   // used for marking detection
-//     float scaling[2]; // calculated according to Dollal paper
+    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+    {
+        workRect.x = round(w / (float)oct.shrinkage);
+        workRect.y = round(h / (float)oct.shrinkage);
 
-//     // for 640x480 we can not get overflow
-//     uchar2 workRect;
-//     uchar2 objSize;
+        objSize.x  = round(oct.size.x * relScale);
+        objSize.y  = round(oct.size.y * relScale);
+    }
+};
 
-//     Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-//     :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-//     {
-//         workRect.x = round(w / (float)oct.shrinkage);
-//         workRect.y = round(h / (float)oct.shrinkage);
+struct __align__(8) Node
+{
+    // int feature;
+    uchar4 rect;
+    float threshold;
 
-//         objSize.x  = round(oct.size.x * relScale);
-//         objSize.y  = round(oct.size.y * relScale);
-//     }
-// };
+    Node(const uchar4 c, const int t) : rect(c), threshold(t) {}
+};
 
+struct __align__(8) Feature
+{
+    int channel;
+    uchar4 rect;
+
+    Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+};
+}
+}}}
 // struct Cascade
 // {
 //     Cascade() {}
@@ -146,21 +159,6 @@
 //     static const float magnitudeScaling = 1.f ;// / sqrt(2);
 // };
 
-// struct __align__(8) Node
-// {
-//     int feature;
-//     float threshold;
-
-//     Node(const int f, const float t) : feature(f), threshold(t) {}
-// };
-
-// struct __align__(8) Feature
-// {
-//     int channel;
-//     uchar4 rect;
-
-//     Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-// };
 // }}}
 
-// #endif
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index f336fd2d9..8d75176ab 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -53,12 +53,15 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat
 
 #else
 
-// #include <icf.hpp>
+#include <icf.hpp>
 
 namespace cv { namespace gpu { namespace device {
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
+    void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
+        const PtrStepSzb& nodes, const PtrStepSzb& features,
+        PtrStepSz<uchar4> objects);
 }
 }}}
 
@@ -82,19 +85,20 @@ struct cv::gpu::SoftCascade::Filds
         integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
         hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 1, CV_32SC1);
     }
-//     // scales range
-//     float minScale;
-//     float maxScale;
 
-//     int origObjWidth;
-//     int origObjHeight;
+    // scales range
+    float minScale;
+    float maxScale;
 
-//     GpuMat octaves;
-//     GpuMat stages;
-//     GpuMat nodes;
-//     GpuMat leaves;
-//     GpuMat features;
-//     GpuMat levels;
+    int origObjWidth;
+    int origObjHeight;
+
+    GpuMat octaves;
+    GpuMat stages;
+    GpuMat nodes;
+    GpuMat leaves;
+    GpuMat features;
+    GpuMat levels;
 
     // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
     GpuMat plane;
@@ -114,312 +118,285 @@ struct cv::gpu::SoftCascade::Filds
     // 161x121x10
     GpuMat hogluv;
 
-//     // will be removed in final version
+    std::vector<float> scales;
 
-
-//     // temp matrix for sobel and cartToPolar
-//     GpuMat dfdx, dfdy, angle, mag, nmag, nangle;
-
-//     std::vector<float> scales;
-
-//     icf::Cascade cascade;
-//     icf::ChannelStorage storage;
-
-//     enum { BOOST = 0 };
+    enum { BOOST = 0 };
     enum
     {
         FRAME_WIDTH        = 640,
         FRAME_HEIGHT       = 480,
-//         TOTAL_SCALES       = 55,
+        TOTAL_SCALES       = 55,
 //         CLASSIFIERS        = 5,
-//         ORIG_OBJECT_WIDTH  = 64,
-//         ORIG_OBJECT_HEIGHT = 128,
+        ORIG_OBJECT_WIDTH  = 64,
+        ORIG_OBJECT_HEIGHT = 128,
         HOG_BINS           = 6,
         LUV_BINS           = 3,
         HOG_LUV_BINS       = 10
     };
 
-//     bool fill(const FileNode &root, const float mins, const float maxs);
-//     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
-//     {
-//         cascade.detect(hogluv, objects, stream);
-//     }
+    bool fill(const FileNode &root, const float mins, const float maxs);
+    void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
+    {
+        device::icf::detect(levels, octaves, stages, nodes, features, objects);
+    }
 
-// private:
-//     void calcLevels(const std::vector<icf::Octave>& octs,
-//                                                     int frameW, int frameH, int nscales);
+private:
+    void calcLevels(const std::vector<device::icf::Octave>& octs,
+                                                    int frameW, int frameH, int nscales);
 
-//     typedef std::vector<icf::Octave>::const_iterator  octIt_t;
-//     int fitOctave(const std::vector<icf::Octave>& octs, const float& logFactor) const
-//     {
-//         float minAbsLog = FLT_MAX;
-//         int res =  0;
-//         for (int oct = 0; oct < (int)octs.size(); ++oct)
-//         {
-//             const icf::Octave& octave =octs[oct];
-//             float logOctave = ::log(octave.scale);
-//             float logAbsScale = ::fabs(logFactor - logOctave);
+    typedef std::vector<device::icf::Octave>::const_iterator  octIt_t;
+    int fitOctave(const std::vector<device::icf::Octave>& octs, const float& logFactor) const
+    {
+        float minAbsLog = FLT_MAX;
+        int res =  0;
+        for (int oct = 0; oct < (int)octs.size(); ++oct)
+        {
+            const device::icf::Octave& octave =octs[oct];
+            float logOctave = ::log(octave.scale);
+            float logAbsScale = ::fabs(logFactor - logOctave);
 
-//             if(logAbsScale < minAbsLog)
-//             {
-//                 res = oct;
-//                 minAbsLog = logAbsScale;
-//             }
-//         }
-//         return res;
-//     }
+            if(logAbsScale < minAbsLog)
+            {
+                res = oct;
+                minAbsLog = logAbsScale;
+            }
+        }
+        return res;
+    }
 };
 
-// inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
-// {
-//     minScale = mins;
-//     maxScale = maxs;
+inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
+{
+    using namespace device::icf;
+    minScale = mins;
+    maxScale = maxs;
 
-//     // cascade properties
-//     static const char *const SC_STAGE_TYPE          = "stageType";
-//     static const char *const SC_BOOST               = "BOOST";
+    // cascade properties
+    static const char *const SC_STAGE_TYPE          = "stageType";
+    static const char *const SC_BOOST               = "BOOST";
 
-//     static const char *const SC_FEATURE_TYPE        = "featureType";
-//     static const char *const SC_ICF                 = "ICF";
+    static const char *const SC_FEATURE_TYPE        = "featureType";
+    static const char *const SC_ICF                 = "ICF";
 
-//     static const char *const SC_ORIG_W              = "width";
-//     static const char *const SC_ORIG_H              = "height";
+    static const char *const SC_ORIG_W              = "width";
+    static const char *const SC_ORIG_H              = "height";
 
-//     static const char *const SC_OCTAVES             = "octaves";
-//     static const char *const SC_STAGES              = "stages";
-//     static const char *const SC_FEATURES            = "features";
+    static const char *const SC_OCTAVES             = "octaves";
+    static const char *const SC_STAGES              = "stages";
+    static const char *const SC_FEATURES            = "features";
 
-//     static const char *const SC_WEEK                = "weakClassifiers";
-//     static const char *const SC_INTERNAL            = "internalNodes";
-//     static const char *const SC_LEAF                = "leafValues";
+    static const char *const SC_WEEK                = "weakClassifiers";
+    static const char *const SC_INTERNAL            = "internalNodes";
+    static const char *const SC_LEAF                = "leafValues";
 
-//     static const char *const SC_OCT_SCALE           = "scale";
-//     static const char *const SC_OCT_STAGES          = "stageNum";
-//     static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
+    static const char *const SC_OCT_SCALE           = "scale";
+    static const char *const SC_OCT_STAGES          = "stageNum";
+    static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
 
-//     static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
+    static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
 
-//     static const char * const SC_F_CHANNEL          = "channel";
-//     static const char * const SC_F_RECT             = "rect";
+    static const char * const SC_F_CHANNEL          = "channel";
+    static const char * const SC_F_RECT             = "rect";
 
-//     // only Ada Boost supported
-//     std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
-//     CV_Assert(stageTypeStr == SC_BOOST);
+    // only Ada Boost supported
+    std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
+    CV_Assert(stageTypeStr == SC_BOOST);
 
-//     // only HOG-like integral channel features cupported
-//     string featureTypeStr = (string)root[SC_FEATURE_TYPE];
-//     CV_Assert(featureTypeStr == SC_ICF);
+    // only HOG-like integral channel features cupported
+    string featureTypeStr = (string)root[SC_FEATURE_TYPE];
+    CV_Assert(featureTypeStr == SC_ICF);
 
-//     origObjWidth = (int)root[SC_ORIG_W];
-//     CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
+    origObjWidth = (int)root[SC_ORIG_W];
+    CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
 
-//     origObjHeight = (int)root[SC_ORIG_H];
-//     CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
+    origObjHeight = (int)root[SC_ORIG_H];
+    CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
 
-//     FileNode fn = root[SC_OCTAVES];
-//         if (fn.empty()) return false;
+    FileNode fn = root[SC_OCTAVES];
+        if (fn.empty()) return false;
 
-//     std::vector<icf::Octave>  voctaves;
-//     std::vector<float>        vstages;
-//     std::vector<icf::Node>    vnodes;
-//     std::vector<float>        vleaves;
-//     std::vector<icf::Feature> vfeatures;
-//     scales.clear();
+    std::vector<Octave>  voctaves;
+    std::vector<float>        vstages;
+    std::vector<Node>    vnodes;
+    std::vector<float>        vleaves;
+    std::vector<Feature> vfeatures;
+    scales.clear();
 
-//     // std::vector<Level> levels;
+    FileNodeIterator it = fn.begin(), it_end = fn.end();
+    int feature_offset = 0;
+    ushort octIndex = 0;
+    ushort shrinkage = 1;
 
-//     FileNodeIterator it = fn.begin(), it_end = fn.end();
-//     int feature_offset = 0;
-//     ushort octIndex = 0;
-//     ushort shrinkage = 1;
+    for (; it != it_end; ++it)
+    {
+        FileNode fns = *it;
+        float scale = (float)fns[SC_OCT_SCALE];
+        scales.push_back(scale);
+        ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
+        ushort2 size;
+        size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
+        size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
+        shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
 
-//     for (; it != it_end; ++it)
-//     {
-//         FileNode fns = *it;
-//         float scale = (float)fns[SC_OCT_SCALE];
-//         scales.push_back(scale);
-//         ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
-//         ushort2 size;
-//         size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
-//         size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
-//         shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
+        Octave octave(octIndex, nstages, shrinkage, size, scale);
+        CV_Assert(octave.stages > 0);
+        voctaves.push_back(octave);
 
-//         icf::Octave octave(octIndex, nstages, shrinkage, size, scale);
-//         CV_Assert(octave.stages > 0);
-//         voctaves.push_back(octave);
+        FileNode ffs = fns[SC_FEATURES];
+        if (ffs.empty()) return false;
 
-//         FileNode ffs = fns[SC_FEATURES];
-//         if (ffs.empty()) return false;
+        fns = fns[SC_STAGES];
+        if (fn.empty()) return false;
 
-//         fns = fns[SC_STAGES];
-//         if (fn.empty()) return false;
+        // for each stage (~ decision tree with H = 2)
+        FileNodeIterator st = fns.begin(), st_end = fns.end();
+        for (; st != st_end; ++st )
+        {
+            fns = *st;
+            vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
 
-//         // for each stage (~ decision tree with H = 2)
-//         FileNodeIterator st = fns.begin(), st_end = fns.end();
-//         for (; st != st_end; ++st )
-//         {
-//             fns = *st;
-//             vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
+            fns = fns[SC_WEEK];
+            FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
+            for (; ftr != ft_end; ++ftr)
+            {
+                fns = (*ftr)[SC_INTERNAL];
+                FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
+                for (; inIt != inIt_end;)
+                {
+                    int feature = (int)(*(inIt +=2)++) + feature_offset;
+                    float th = (float)(*(inIt++));
+                    uchar4 rect;
+                    vnodes.push_back(Node(rect, th));
+                }
 
-//             fns = fns[SC_WEEK];
-//             FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
-//             for (; ftr != ft_end; ++ftr)
-//             {
-//                 fns = (*ftr)[SC_INTERNAL];
-//                 FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
-//                 for (; inIt != inIt_end;)
-//                 {
-//                     int feature = (int)(*(inIt +=2)++) + feature_offset;
-//                     float th = (float)(*(inIt++));
-//                     vnodes.push_back(icf::Node(feature, th));
-//                 }
+                fns = (*ftr)[SC_LEAF];
+                inIt = fns.begin(), inIt_end = fns.end();
+                for (; inIt != inIt_end; ++inIt)
+                    vleaves.push_back((float)(*inIt));
+            }
+        }
 
-//                 fns = (*ftr)[SC_LEAF];
-//                 inIt = fns.begin(), inIt_end = fns.end();
-//                 for (; inIt != inIt_end; ++inIt)
-//                     vleaves.push_back((float)(*inIt));
-//             }
-//         }
+        st = ffs.begin(), st_end = ffs.end();
+        for (; st != st_end; ++st )
+        {
+            cv::FileNode rn = (*st)[SC_F_RECT];
+            cv::FileNodeIterator r_it = rn.begin();
+            uchar4 rect;
+            rect.x = saturate_cast<uchar>((int)*(r_it++));
+            rect.y = saturate_cast<uchar>((int)*(r_it++));
+            rect.z = saturate_cast<uchar>((int)*(r_it++));
+            rect.w = saturate_cast<uchar>((int)*(r_it++));
+            vfeatures.push_back(Feature((int)(*st)[SC_F_CHANNEL], rect));
+        }
 
-//         st = ffs.begin(), st_end = ffs.end();
-//         for (; st != st_end; ++st )
-//         {
-//             cv::FileNode rn = (*st)[SC_F_RECT];
-//             cv::FileNodeIterator r_it = rn.begin();
-//             uchar4 rect;
-//             rect.x = saturate_cast<uchar>((int)*(r_it++));
-//             rect.y = saturate_cast<uchar>((int)*(r_it++));
-//             rect.z = saturate_cast<uchar>((int)*(r_it++));
-//             rect.w = saturate_cast<uchar>((int)*(r_it++));
-//             vfeatures.push_back(icf::Feature((int)(*st)[SC_F_CHANNEL], rect));
-//         }
+        feature_offset += octave.stages * 3;
+        ++octIndex;
+    }
 
-//         feature_offset += octave.stages * 3;
-//         ++octIndex;
-//     }
+    // upload in gpu memory
+    octaves.upload(cv::Mat(1, voctaves.size() * sizeof(Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
+    CV_Assert(!octaves.empty());
 
-//     // upload in gpu memory
-//     octaves.upload(cv::Mat(1, voctaves.size() * sizeof(icf::Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
-//     CV_Assert(!octaves.empty());
+    stages.upload(cv::Mat(vstages).reshape(1,1));
+    CV_Assert(!stages.empty());
 
-//     stages.upload(cv::Mat(vstages).reshape(1,1));
-//     CV_Assert(!stages.empty());
+    nodes.upload(cv::Mat(1, vnodes.size() * sizeof(Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
+    CV_Assert(!nodes.empty());
 
-//     nodes.upload(cv::Mat(1, vnodes.size() * sizeof(icf::Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
-//     CV_Assert(!nodes.empty());
+    leaves.upload(cv::Mat(vleaves).reshape(1,1));
+    CV_Assert(!leaves.empty());
 
-//     leaves.upload(cv::Mat(vleaves).reshape(1,1));
-//     CV_Assert(!leaves.empty());
+    features.upload(cv::Mat(1, vfeatures.size() * sizeof(Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
+    CV_Assert(!features.empty());
 
-//     features.upload(cv::Mat(1, vfeatures.size() * sizeof(icf::Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
-//     CV_Assert(!features.empty());
+    // compute levels
+    calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
+    CV_Assert(!levels.empty());
 
-//     // compute levels
-//     calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
-//     CV_Assert(!levels.empty());
+    return true;
+}
 
-//     //init Cascade
-//     cascade = icf::Cascade(octaves, stages, nodes, leaves, features, levels);
+namespace {
+    struct CascadeIntrinsics
+    {
+        static const float lambda = 1.099f, a = 0.89f;
 
-//     // allocate buffers
-//     dmem.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
-//     shrunk.create(FRAME_HEIGHT / shrinkage * HOG_LUV_BINS, FRAME_WIDTH / shrinkage, CV_8UC1);
-//     // hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_16UC1);
-//     hogluv.create( (FRAME_HEIGHT / shrinkage + 1) * HOG_LUV_BINS, (FRAME_WIDTH / shrinkage + 1), CV_32SC1);
-//     luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
-//     integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
+        static float getFor(int channel, float scaling)
+        {
+            CV_Assert(channel < 10);
 
-//     dfdx.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-//     dfdy.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-//     angle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-//     mag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+            if (fabs(scaling - 1.f) < FLT_EPSILON)
+                return 1.f;
 
-//     nmag.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
-//     nangle.create(FRAME_HEIGHT, FRAME_WIDTH, CV_32FC1);
+            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
+            static const float A[2][2] =
+            {   //channel <= 6, otherwise
+                {        0.89f, 1.f}, // down
+                {        1.00f, 1.f}  // up
+            };
 
-//     storage = icf::ChannelStorage(dmem, shrunk, hogluv, shrinkage);
-//     return true;
-// }
+            static const float B[2][2] =
+            {   //channel <= 6,  otherwise
+                { 1.099f / log(2), 2.f}, // down
+                {             0.f, 2.f}  // up
+            };
 
-// namespace {
-//     struct CascadeIntrinsics
-//     {
-//         static const float lambda = 1.099f, a = 0.89f;
+            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
+            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
 
-//         static float getFor(int channel, float scaling)
-//         {
-//             CV_Assert(channel < 10);
+            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
+            return a * pow(scaling, b);
+        }
+    };
+}
 
-//             if (fabs(scaling - 1.f) < FLT_EPSILON)
-//                 return 1.f;
+inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<device::icf::Octave>& octs,
+                                                    int frameW, int frameH, int nscales)
+{
+    CV_Assert(nscales > 1);
+    using device::icf::Level;
 
-//             // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
-//             static const float A[2][2] =
-//             {   //channel <= 6, otherwise
-//                 {        0.89f, 1.f}, // down
-//                 {        1.00f, 1.f}  // up
-//             };
+    std::vector<Level> vlevels;
+    float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
 
-//             static const float B[2][2] =
-//             {   //channel <= 6,  otherwise
-//                 { 1.099f / log(2), 2.f}, // down
-//                 {             0.f, 2.f}  // up
-//             };
+    float scale = minScale;
+    for (int sc = 0; sc < nscales; ++sc)
+    {
+        int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
+        int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
 
-//             float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
-//             float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
+        float logScale = ::log(scale);
+        int fit = fitOctave(octs, logScale);
 
-//             // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
-//             return a * pow(scaling, b);
-//         }
-//     };
-// }
+        Level level(fit, octs[fit], scale, width, height);
+        level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
+        level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
 
-// inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<icf::Octave>& octs,
-//                                                     int frameW, int frameH, int nscales)
-// {
-//     CV_Assert(nscales > 1);
+        if (!width || !height)
+            break;
+        else
+            vlevels.push_back(level);
 
-//     std::vector<icf::Level> vlevels;
-//     float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
+        if (::fabs(scale - maxScale) < FLT_EPSILON) break;
+        scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
-//     float scale = minScale;
-//     for (int sc = 0; sc < nscales; ++sc)
-//     {
-//         int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
-//         int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
+        // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
+        //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x,
+        //level.objSize.y);
 
-//         float logScale = ::log(scale);
-//         int fit = fitOctave(octs, logScale);
+        std::cout << "level " << sc
+                  << " octeve "
+                  << vlevels[sc].octave
+                  << " relScale "
+                  << vlevels[sc].relScale
+                  << " " << vlevels[sc].shrScale
+                  << " [" << (int)vlevels[sc].objSize.x
+                  << " " <<  (int)vlevels[sc].objSize.y << "] ["
+        <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
+    }
 
-//         icf::Level level(fit, octs[fit], scale, width, height);
-//         level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
-//         level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
-
-//         if (!width || !height)
-//             break;
-//         else
-//             vlevels.push_back(level);
-
-//         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
-//         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
-
-//         // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-//         //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x,
-//level.objSize.y);
-
-//         // std::cout << "level " << sc
-//         //           << " octeve "
-//         //           << vlevels[sc].octave
-//         //           << " relScale "
-//         //           << vlevels[sc].relScale
-//         //           << " " << vlevels[sc].shrScale
-//         //           << " [" << (int)vlevels[sc].objSize.x
-//         //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
-//         // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
-//     }
-//     levels.upload(cv::Mat(1, vlevels.size() * sizeof(icf::Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
-// }
+    levels.upload(cv::Mat(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
+}
 
 cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
 
@@ -444,7 +421,7 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
 
     filds = new Filds;
     Filds& flds = *filds;
-    // if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
+    if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
     return true;
 }
 
@@ -538,7 +515,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 
     cudaStream_t stream = StreamAccessor::getStream(s);
     // detection
-//     flds.detect(objects, stream);
+    flds.detect(objects, stream);
 
 //     // flds.storage.frame(colored, stream);
 }

From 8108bd30febf17e81f8329ccb65f695dd335a471 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 27 Sep 2012 12:44:06 +0400
Subject: [PATCH 024/155] optimize memory usage

---
 modules/gpu/src/cuda/isf-sc.cu  | 306 +++++++++++++-------------------
 modules/gpu/src/icf.hpp         |  29 +--
 modules/gpu/src/softcascade.cpp |  86 +++++----
 3 files changed, 180 insertions(+), 241 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 714bdfa44..c8dff34bd 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -42,18 +42,17 @@
 
 #include <opencv2/gpu/device/common.hpp>
 #include <icf.hpp>
-// #include <opencv2/gpu/device/saturate_cast.hpp>
 #include <stdio.h>
-// #include <float.h>
+#include <float.h>
 
-// //#define LOG_CUDA_CASCADE
+// #define LOG_CUDA_CASCADE
 
-// #if defined LOG_CUDA_CASCADE
-// # define dprintf(format, ...) \
-//             do { printf(format, __VA_ARGS__); } while (0)
-// #else
-// # define dprintf(format, ...)
-// #endif
+#if defined LOG_CUDA_CASCADE
+# define dprintf(format, ...) \
+            do { printf(format, __VA_ARGS__); } while (0)
+#else
+# define dprintf(format, ...)
+#endif
 
 namespace cv { namespace gpu { namespace device {
 namespace icf {
@@ -94,32 +93,128 @@ namespace icf {
         cudaSafeCall( cudaDeviceSynchronize() );
     }
 
-    texture<float2,  cudaTextureType1D, cudaReadModeElementType> tnode;
+    texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
+    // ToDo: do it in load time
+    // __device__ __forceinline__ float rescale(const Level& level, uchar4& scaledRect, const Node& node)
+    // {
+    //     scaledRect = node.rect;
+    //     return (float)(node.threshold & 0x0FFFFFFFU);
+    // }
+
+    __device__ __forceinline__ float rescale(const Level& level, uchar4& scaledRect, const Node& node)
+    {
+        float relScale = level.relScale;
+        float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
+
+        dprintf("feature %d box %d %d %d %d\n", (node.threshold >> 28), scaledRect.x, scaledRect.y,
+            scaledRect.z, scaledRect.w);
+        dprintf("rescale: %f [%f %f] selected %f\n",level.relScale, level.scaling[0], level.scaling[1],
+            level.scaling[(node.threshold >> 28) > 6]);
+
+        // rescale
+        scaledRect.x = __float2int_rn(relScale * scaledRect.x);
+        scaledRect.y = __float2int_rn(relScale * scaledRect.y);
+        scaledRect.z = __float2int_rn(relScale * scaledRect.z);
+        scaledRect.w = __float2int_rn(relScale * scaledRect.w);
+
+        float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
+
+        float approx = 1.f;
+        // if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
+        {
+            const float expected_new_area = farea * relScale * relScale;
+            approx =  sarea / expected_new_area;
+        }
+
+        dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", (node.threshold >> 28),
+        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
+
+
+        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
+        rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
+
+        dprintf("approximation %f %d -> %f %f\n", approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
+            level.scaling[(node.threshold >> 28) > 6]);
+
+        return rootThreshold;
+    }
+
+    __device__ __forceinline__ int get(const int x, int y, int channel, uchar4 area)
+    {
+
+        dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
+        dprintf("get for channel %d\n", channel);
+        dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
+            x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
+            x + area.x, y + area.w);
+        dprintf("at point %d %d with offset %d\n", x, y, 0);
+
+        int offset = channel * 121;
+        y += offset;
+
+        int a = tex2D(thogluv, x + area.x, y + area.y);
+        int b = tex2D(thogluv, x + area.z, y + area.y);
+        int c = tex2D(thogluv, x + area.z, y + area.w);
+        int d = tex2D(thogluv, x + area.x, y + area.w);
+
+        dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
+
+        return (a - b + c - d);
+    }
+
     __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes,
-        PtrStepSz<uchar4> objects)
+        const Node* nodes, const float* leaves, PtrStepSz<uchar4> objects)
     {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         Level level = levels[blockIdx.z];
+
+        // if (x > 0 || y > 0 || blockIdx.z > 0) return;
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
         Octave octave = octaves[level.octave];
+
         int st = octave.index * octave.stages;
         const int stEnd = st + 1000;//octave.stages;
 
         float confidence = 0.f;
 
-#pragma unroll 8
+// #pragma unroll 8
         for(; st < stEnd; ++st)
         {
+            dprintf("\n\nstage: %d\n", st);
             const int nId = st * 3;
-            const Node node = nodes[nId];
+            Node node = nodes[nId];
 
-            const float stage = stages[st];
-            confidence += node.rect.x * stage;
+            dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
+                node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
+
+            float threshold = rescale(level, node.rect, node);
+            int sum = get(x, y, (node.threshold >> 28), node.rect);
+
+            dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
+                node.rect.w, threshold);
+
+            int next = 1 + (int)(sum >= threshold);
+            dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
+
+            node = nodes[nId + next];
+            threshold = rescale(level, node.rect, node);
+            sum = get(x, y, (node.threshold >> 28), node.rect);
+
+            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+            float impact = leaves[st * 4 + lShift];
+            confidence += impact;
+
+            if (confidence <= stages[st]) st = stEnd + 1;
+            dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+            dprintf("extracted stage: %f\n", stages[st]);
+            dprintf("computed  score: %f\n\n", confidence);
         }
 
+        // if (st == stEnd)
+        //     printf("%d %d %d\n", x, y, st);
+
         uchar4 val;
         val.x = (int)confidence;
         if (x == y) objects(0, threadIdx.x) = val;
@@ -127,188 +222,27 @@ namespace icf {
     }
 
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzb& features,
-        PtrStepSz<uchar4> objects)
+        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects)
     {
         int fw = 160;
         int fh = 120;
+
         dim3 block(32, 8);
         dim3 grid(fw / 32, fh / 8, 47);
+
         const Level* l = (const Level*)levels.ptr();
         const Octave* oct = ((const Octave*)octaves.ptr());
         const float* st = (const float*)stages.ptr();
         const Node* nd = (const Node*)nodes.ptr();
-        // cudaSafeCall( cudaBindTexture(0, tnode, nodes.data, rgb.cols / size) );
+        const float* lf = (const float*)leaves.ptr();
 
-        test_kernel<<<grid, block>>>(l, oct, st, nd, objects);
+        cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
+        cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
+
+        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, objects);
 
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
     }
 }
-}}}
-
-// __global__ void detect(const cv::gpu::icf::Cascade cascade, const int* __restrict__ hogluv, const int pitch,
-//     PtrStepSz<uchar4> objects)
-// {
-//     cascade.detectAt(hogluv, pitch, objects);
-// }
-
-// }
-
-// float __device icf::Cascade::rescale(const icf::Level& level, uchar4& scaledRect,
-//                                      const int channel, const float threshold) const
-// {
-//     dprintf("feature %d box %d %d %d %d\n", channel, scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w);
-//     dprintf("rescale: %f [%f %f]\n",level.relScale, level.scaling[0], level.scaling[1]);
-
-//     float relScale = level.relScale;
-//     float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
-
-//     // rescale
-//     scaledRect.x = __float2int_rn(relScale * scaledRect.x);
-//     scaledRect.y = __float2int_rn(relScale * scaledRect.y);
-//     scaledRect.z = __float2int_rn(relScale * scaledRect.z);
-//     scaledRect.w = __float2int_rn(relScale * scaledRect.w);
-
-//     float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
-
-
-//     float approx = 1.f;
-//     if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
-//     {
-//         const float expected_new_area = farea * relScale * relScale;
-//         approx = expected_new_area / sarea;
-//     }
-
-//     dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", channel,
-//         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
-
-//     // compensation areas rounding
-//     float rootThreshold = threshold / approx;
-//     // printf("    approx %f\n", rootThreshold);
-//     rootThreshold *= level.scaling[(int)(channel > 6)];
-
-//     dprintf("approximation %f %f -> %f %f\n", approx, threshold, rootThreshold, level.scaling[(int)(channel > 6)]);
-
-//     return rootThreshold;
-// }
-
-// typedef unsigned char uchar;
-// float __device get(const int* __restrict__ hogluv, const int pitch,
-//                    const int x, const int y, int channel, uchar4 area)
-// {
-//     dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
-//     dprintf("get for channel %d\n", channel);
-//     dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
-//         x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
-//         x + area.x, y + area.w);
-//     dprintf("at point %d %d with offset %d\n", x, y, 0);
-
-//     const int* curr = hogluv + ((channel * 121) + y) * pitch;
-
-//     int a = curr[area.y * pitch + x + area.x];
-//     int b = curr[area.y * pitch + x + area.z];
-//     int c = curr[area.w * pitch + x + area.z];
-//     int d = curr[area.w * pitch + x + area.x];
-
-//     dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
-
-//     return (a - b + c - d);
-// }
-
-
-// void __device icf::Cascade::detectAt(const int* __restrict__ hogluv, const int pitch,
-//                                     PtrStepSz<uchar4>& objects) const
-// {
-//     const icf::Level* lls = (const icf::Level*)levels.ptr();
-
-//     const int y = blockIdx.y * blockDim.y + threadIdx.y;
-//     const int x = blockIdx.x * blockDim.x + threadIdx.x;
-//     // if (x > 0 || y > 0) return;
-
-//     Level level = lls[blockIdx.z];
-//     if (x >= level.workRect.x || y >= level.workRect.y) return;
-
-//     dprintf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-//         level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x, level.objSize.y);
-
-//     const Octave octave = ((const Octave*)octaves.ptr())[level.octave];
-//     // printf("Octave: %d %d %d (%d %d) %f\n", octave.index, octave.stages,
-//     //     octave.shrinkage, octave.size.x, octave.size.y, octave.scale);
-
-//     const int stBegin = octave.index * octave.stages, stEnd = stBegin + octave.stages;
-
-//     float detectionScore = 0.f;
-
-//     int st = stBegin;
-//     for(; st < stEnd; ++st)
-//     {
-//         const float stage = stages(0, st);
-//         dprintf("Stage: %f\n", stage);
-//         {
-//             const int nId = st * 3;
-
-//             // work with root node
-//             const Node node = ((const Node*)nodes.ptr())[nId];
-
-//             dprintf("Node: %d %f\n", node.feature, node.threshold);
-
-//             const Feature feature = ((const Feature*)features.ptr())[node.feature];
-
-//             uchar4 scaledRect = feature.rect;
-//             float threshold = rescale(level, scaledRect, feature.channel, node.threshold);
-
-//             float sum = get(hogluv,pitch, x, y, feature.channel, scaledRect);
-
-//             dprintf("root feature %d %f\n",feature.channel, sum);
-
-//             int next = 1 + (int)(sum >= threshold);
-
-//             dprintf("go: %d (%f >= %f)\n\n" ,next, sum, threshold);
-
-//             // leaves
-//             const Node leaf = ((const Node*)nodes.ptr())[nId + next];
-//             const Feature fLeaf = ((const Feature*)features.ptr())[leaf.feature];
-
-//             scaledRect = fLeaf.rect;
-//             threshold = rescale(level, scaledRect, fLeaf.channel, leaf.threshold);
-//             sum = get(hogluv, pitch, x, y, fLeaf.channel, scaledRect);
-
-//             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-//             float impact = leaves(0, (st * 4) + lShift);
-
-//             detectionScore += impact;
-
-//             dprintf("decided: %d (%f >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-//             dprintf("extracted stage:\n");
-//             dprintf("ct %f\n", stage);
-//             dprintf("computed score %f\n\n", detectionScore);
-//             dprintf("\n\n");
-//         }
-
-//         if (detectionScore <= stage || st - stBegin == 100) break;
-//     }
-
-//     dprintf("x %d y %d: %d\n", x, y, st - stBegin);
-
-//     if (st == stEnd)
-//     {
-//         uchar4 a;
-//         a.x = level.workRect.x;
-//         a.y = level.workRect.y;
-//         objects(0, threadIdx.x) = a;
-//     }
-// }
-
-// void icf::Cascade::detect(const cv::gpu::PtrStepSzi& hogluv, PtrStepSz<uchar4> objects, cudaStream_t stream) const
-// {
-//     dim3 block(32, 8, 1);
-//     dim3 grid(ChannelStorage::FRAME_WIDTH / 32, ChannelStorage::FRAME_HEIGHT / 8, 47);
-//     device::detect<<<grid, block, 0, stream>>>(*this, hogluv, hogluv.step / sizeof(int), objects);
-//     cudaSafeCall( cudaGetLastError() );
-//     if (!stream)
-//         cudaSafeCall( cudaDeviceSynchronize() );
-// }
-
-// }}
\ No newline at end of file
+}}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 51ea2c068..ecd1886d3 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -40,11 +40,13 @@
 //
 //M
 
-#include <opencv2/gpu/device/common.hpp>
 
 #ifndef __OPENCV_ICF_HPP__
 #define __OPENCV_ICF_HPP__
 
+#include <opencv2/gpu/device/common.hpp>
+#include <stdio.h>
+
 // #if defined __CUDACC__
 // # define __device __device__ __forceinline__
 // #else
@@ -92,20 +94,27 @@ struct __align__(8) Level //is actually 24 bytes
 
 struct __align__(8) Node
 {
-    // int feature;
     uchar4 rect;
-    float threshold;
+    // ushort channel;
+    uint threshold;
 
-    Node(const uchar4 c, const int t) : rect(c), threshold(t) {}
+    enum { THRESHOLD_MASK = 0x0FFFFFFF };
+
+    Node(const uchar4 r, const uint ch, const uint t) : rect(r), threshold(t + (ch << 28))
+    {
+        // printf("%d\n", t);
+        // printf("[%d %d %d %d] %d, %d\n",rect.x, rect.y, rect.z, rect.w, (int)(threshold >> 28),
+        //     (int)(0x0FFFFFFF & threshold));
+    }
 };
 
-struct __align__(8) Feature
-{
-    int channel;
-    uchar4 rect;
+// struct __align__(8) Feature
+// {
+//     int channel;
+//     uchar4 rect;
 
-    Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-};
+//     Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
+// };
 }
 }}}
 // struct Cascade
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 8d75176ab..ffbf380c6 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -60,19 +60,10 @@ namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzb& features,
-        PtrStepSz<uchar4> objects);
+        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects);
 }
 }}}
 
-// namespace {
-//     char *itoa(long i, char* s, int /*dummy_radix*/)
-//     {
-//         sprintf(s, "%ld", i);
-//         return s;
-//     }
-// }
-
 struct cv::gpu::SoftCascade::Filds
 {
 
@@ -97,7 +88,6 @@ struct cv::gpu::SoftCascade::Filds
     GpuMat stages;
     GpuMat nodes;
     GpuMat leaves;
-    GpuMat features;
     GpuMat levels;
 
     // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
@@ -137,7 +127,7 @@ struct cv::gpu::SoftCascade::Filds
     bool fill(const FileNode &root, const float mins, const float maxs);
     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
-        device::icf::detect(levels, octaves, stages, nodes, features, objects);
+        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects);
     }
 
 private:
@@ -216,10 +206,9 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
         if (fn.empty()) return false;
 
     std::vector<Octave>  voctaves;
-    std::vector<float>        vstages;
+    std::vector<float>   vstages;
     std::vector<Node>    vnodes;
-    std::vector<float>        vleaves;
-    std::vector<Feature> vfeatures;
+    std::vector<float>   vleaves;
     scales.clear();
 
     FileNodeIterator it = fn.begin(), it_end = fn.end();
@@ -245,6 +234,8 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
         FileNode ffs = fns[SC_FEATURES];
         if (ffs.empty()) return false;
 
+        FileNodeIterator ftrs = ffs.begin();
+
         fns = fns[SC_STAGES];
         if (fn.empty()) return false;
 
@@ -263,10 +254,21 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
                 FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
                 for (; inIt != inIt_end;)
                 {
-                    int feature = (int)(*(inIt +=2)++) + feature_offset;
-                    float th = (float)(*(inIt++));
+                    // int feature = (int)(*(inIt +=2)) + feature_offset;
+                    inIt +=3;
+                    // extract feature, Todo:check it
+                    uint th = saturate_cast<uint>((float)(*(inIt++)));
+                    cv::FileNode ftn = (*ftrs)[SC_F_RECT];
+                    cv::FileNodeIterator r_it = ftn.begin();
                     uchar4 rect;
-                    vnodes.push_back(Node(rect, th));
+                    rect.x = saturate_cast<uchar>((int)*(r_it++));
+                    rect.y = saturate_cast<uchar>((int)*(r_it++));
+                    rect.z = saturate_cast<uchar>((int)*(r_it++));
+                    rect.w = saturate_cast<uchar>((int)*(r_it++));
+
+                    uint channel = saturate_cast<uint>((int)(*ftrs)[SC_F_CHANNEL]);
+                    vnodes.push_back(Node(rect, channel, th));
+                    ++ftrs;
                 }
 
                 fns = (*ftr)[SC_LEAF];
@@ -276,19 +278,6 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
             }
         }
 
-        st = ffs.begin(), st_end = ffs.end();
-        for (; st != st_end; ++st )
-        {
-            cv::FileNode rn = (*st)[SC_F_RECT];
-            cv::FileNodeIterator r_it = rn.begin();
-            uchar4 rect;
-            rect.x = saturate_cast<uchar>((int)*(r_it++));
-            rect.y = saturate_cast<uchar>((int)*(r_it++));
-            rect.z = saturate_cast<uchar>((int)*(r_it++));
-            rect.w = saturate_cast<uchar>((int)*(r_it++));
-            vfeatures.push_back(Feature((int)(*st)[SC_F_CHANNEL], rect));
-        }
-
         feature_offset += octave.stages * 3;
         ++octIndex;
     }
@@ -306,9 +295,6 @@ inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float
     leaves.upload(cv::Mat(vleaves).reshape(1,1));
     CV_Assert(!leaves.empty());
 
-    features.upload(cv::Mat(1, vfeatures.size() * sizeof(Feature), CV_8UC1, (uchar*)&(vfeatures[0]) ));
-    CV_Assert(!features.empty());
-
     // compute levels
     calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
     CV_Assert(!levels.empty());
@@ -425,7 +411,14 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     return true;
 }
 
-// #define USE_REFERENCE_VALUES
+#define USE_REFERENCE_VALUES
+namespace {
+    char *itoa(long i, char* s, int /*dummy_radix*/)
+    {
+        sprintf(s, "%ld", i);
+        return s;
+    }
+}
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
                                 GpuMat& objects, const int /*rejectfactor*/, Stream s)
 {
@@ -438,17 +431,20 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     Filds& flds = *filds;
 
 #if defined USE_REFERENCE_VALUES
-//     cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
-//     cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
-//     char buff[33];
+    cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
 
-//     for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-//     {
-//         cv::Mat channel;
-//         imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
-//         GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
-//         gchannel.upload(channel);
-//     }
+    cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
+    char buff[33];
+
+    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+    {
+        cv::Mat channel;
+        imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
+
+        // std::cout << "channel " << i << std::endl << channel << std::endl;
+        GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
 #else
     GpuMat& plane = flds.plane;
     GpuMat& shrunk = flds.shrunk;

From 72b499df006a39185b529861f40e335611ebccc8 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 27 Sep 2012 14:40:13 +0400
Subject: [PATCH 025/155] add detection storing

---
 modules/gpu/perf/perf_objdetect.cpp |  4 +-
 modules/gpu/src/cuda/isf-sc.cu      | 59 ++++++++++-------------------
 modules/gpu/src/softcascade.cpp     | 14 ++++---
 3 files changed, 30 insertions(+), 47 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 48a355d6a..e272d6535 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -104,7 +104,7 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
         cv::gpu::SoftCascade cascade;
         ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
 
-        cv::gpu::GpuMat rois, objectBoxes(1, 1000, CV_8UC1);
+        cv::gpu::GpuMat rois, objectBoxes(1, 1000, CV_8UC4);
         cascade.detectMultiScale(colored, rois, objectBoxes);
 
         TEST_CYCLE()
@@ -117,7 +117,7 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
         ASSERT_FALSE(colored.empty());
 
         cv::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(GetParam().first));
+        ASSERT_TRUE(cascade.load(getDataPath(GetParam().first)));
 
         std::vector<cv::Rect> rois, objectBoxes;
         cascade.detectMultiScale(colored, rois, objectBoxes);
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index c8dff34bd..4bf410fc5 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -57,14 +57,6 @@
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
-//     enum {
-//         HOG_BINS = 6,
-//         HOG_LUV_BINS = 10,
-//         WIDTH = 640,
-//         HEIGHT = 480,
-//         GREY_OFFSET = HEIGHT * HOG_LUV_BINS
-//     };
-
     // ToDo: use textures or ancached load instruction.
     __global__ void magToHist(const uchar* __restrict__ mag,
                               const float* __restrict__ angle, const int angPitch,
@@ -94,13 +86,6 @@ namespace icf {
     }
 
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
-    // ToDo: do it in load time
-    // __device__ __forceinline__ float rescale(const Level& level, uchar4& scaledRect, const Node& node)
-    // {
-    //     scaledRect = node.rect;
-    //     return (float)(node.threshold & 0x0FFFFFFFU);
-    // }
-
     __device__ __forceinline__ float rescale(const Level& level, uchar4& scaledRect, const Node& node)
     {
         float relScale = level.relScale;
@@ -119,17 +104,12 @@ namespace icf {
 
         float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
-        float approx = 1.f;
-        // if (fabs(farea - 0.f) > FLT_EPSILON && fabs(farea - 0.f) > FLT_EPSILON)
-        {
-            const float expected_new_area = farea * relScale * relScale;
-            approx =  sarea / expected_new_area;
-        }
+        const float expected_new_area = farea * relScale * relScale;
+        float approx =  sarea / expected_new_area;
 
         dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", (node.threshold >> 28),
         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
 
-
         float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
         rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
 
@@ -139,7 +119,7 @@ namespace icf {
         return rootThreshold;
     }
 
-    __device__ __forceinline__ int get(const int x, int y, int channel, uchar4 area)
+    __device__ __forceinline__ int get(const int x, int y, uchar4 area)
     {
 
         dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
@@ -149,9 +129,6 @@ namespace icf {
             x + area.x, y + area.w);
         dprintf("at point %d %d with offset %d\n", x, y, 0);
 
-        int offset = channel * 121;
-        y += offset;
-
         int a = tex2D(thogluv, x + area.x, y + area.y);
         int b = tex2D(thogluv, x + area.z, y + area.y);
         int c = tex2D(thogluv, x + area.z, y + area.w);
@@ -163,7 +140,7 @@ namespace icf {
     }
 
     __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes, const float* leaves, PtrStepSz<uchar4> objects)
+        const Node* nodes, const float* leaves, PtrStepSz<uchar4> objects, uint* ctr)
     {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
@@ -179,7 +156,7 @@ namespace icf {
 
         float confidence = 0.f;
 
-// #pragma unroll 8
+// #pragma unroll 2
         for(; st < stEnd; ++st)
         {
             dprintf("\n\nstage: %d\n", st);
@@ -190,7 +167,7 @@ namespace icf {
                 node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
 
             float threshold = rescale(level, node.rect, node);
-            int sum = get(x, y, (node.threshold >> 28), node.rect);
+            int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
 
             dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
                 node.rect.w, threshold);
@@ -200,29 +177,30 @@ namespace icf {
 
             node = nodes[nId + next];
             threshold = rescale(level, node.rect, node);
-            sum = get(x, y, (node.threshold >> 28), node.rect);
+            sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
             float impact = leaves[st * 4 + lShift];
             confidence += impact;
 
-            if (confidence <= stages[st]) st = stEnd + 1;
+            if (confidence <= stages[st]) st = stEnd + 10;
             dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
             dprintf("extracted stage: %f\n", stages[st]);
             dprintf("computed  score: %f\n\n", confidence);
         }
 
-        // if (st == stEnd)
-        //     printf("%d %d %d\n", x, y, st);
-
-        uchar4 val;
-        val.x = (int)confidence;
-        if (x == y) objects(0, threadIdx.x) = val;
-
+        if(st == stEnd)
+        {
+            int idx = atomicInc(ctr, objects.cols);
+            uchar4 val;
+            val.x = x * 4;
+            objects(0, idx) = val;
+        }
     }
 
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects)
+                const PtrStepSzb& nodes,  const PtrStepSzf& leaves,  const PtrStepSzi& hogluv,
+                PtrStepSz<uchar4> objects, PtrStepSzi counter)
     {
         int fw = 160;
         int fh = 120;
@@ -235,11 +213,12 @@ namespace icf {
         const float* st = (const float*)stages.ptr();
         const Node* nd = (const Node*)nodes.ptr();
         const float* lf = (const float*)leaves.ptr();
+        uint* ctr = (uint*)counter.ptr();
 
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, objects);
+        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, objects, ctr);
 
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index ffbf380c6..320fbb343 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -60,7 +60,8 @@ namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects);
+        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
+        PtrStepSzi counter);
 }
 }}}
 
@@ -75,6 +76,7 @@ struct cv::gpu::SoftCascade::Filds
         shrunk.create(FRAME_HEIGHT / 4 * HOG_LUV_BINS, FRAME_WIDTH / 4, CV_8UC1);
         integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
         hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 1, CV_32SC1);
+        detCounter.create(1,1, CV_32SC1);
     }
 
     // scales range
@@ -90,6 +92,8 @@ struct cv::gpu::SoftCascade::Filds
     GpuMat leaves;
     GpuMat levels;
 
+    GpuMat detCounter;
+
     // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
     GpuMat plane;
 
@@ -127,7 +131,8 @@ struct cv::gpu::SoftCascade::Filds
     bool fill(const FileNode &root, const float mins, const float maxs);
     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
-        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects);
+        cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
+        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter);
     }
 
 private:
@@ -506,14 +511,13 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
         GpuMat sum(flds.hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
         cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
     }
-
 #endif
 
     cudaStream_t stream = StreamAccessor::getStream(s);
-    // detection
     flds.detect(objects, stream);
 
-//     // flds.storage.frame(colored, stream);
+        //     cv::Mat out(flds.detCounter);
+        // std::cout << out << std::endl;
 }
 
 #endif
\ No newline at end of file

From c0359ed5c5987a3e58151cec20fd866fab3776ca Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 27 Sep 2012 16:50:47 +0400
Subject: [PATCH 026/155] fix test: enough size for detection matrix

---
 modules/gpu/perf/perf_objdetect.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index e272d6535..8531372b0 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -104,7 +104,7 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
         cv::gpu::SoftCascade cascade;
         ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
 
-        cv::gpu::GpuMat rois, objectBoxes(1, 1000, CV_8UC4);
+        cv::gpu::GpuMat rois, objectBoxes(1, 16384, CV_8UC1);
         cascade.detectMultiScale(colored, rois, objectBoxes);
 
         TEST_CYCLE()

From 0314e0e5d74e0e6c979505448c5eb103c2181989 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 27 Sep 2012 16:54:37 +0400
Subject: [PATCH 027/155] add kind in detection representation

---
 modules/gpu/src/cuda/isf-sc.cu | 17 +++----
 modules/gpu/src/icf.hpp        | 81 ++++++++--------------------------
 2 files changed, 27 insertions(+), 71 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 4bf410fc5..adfc9edcb 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -123,7 +123,6 @@ namespace icf {
     {
 
         dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
-        dprintf("get for channel %d\n", channel);
         dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
             x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
             x + area.x, y + area.w);
@@ -140,13 +139,13 @@ namespace icf {
     }
 
     __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes, const float* leaves, PtrStepSz<uchar4> objects, uint* ctr)
+        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr)
     {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         Level level = levels[blockIdx.z];
 
-        // if (x > 0 || y > 0 || blockIdx.z > 0) return;
+        // if (blockIdx.z != 31) return;
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
         Octave octave = octaves[level.octave];
@@ -191,10 +190,10 @@ namespace icf {
 
         if(st == stEnd)
         {
-            int idx = atomicInc(ctr, objects.cols);
-            uchar4 val;
-            val.x = x * 4;
-            objects(0, idx) = val;
+            int idx = atomicInc(ctr, ndetections);
+            // store detection
+            objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
+                __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
         }
     }
 
@@ -214,11 +213,13 @@ namespace icf {
         const Node* nd = (const Node*)nodes.ptr();
         const float* lf = (const float*)leaves.ptr();
         uint* ctr = (uint*)counter.ptr();
+        Detection* det = (Detection*)objects.ptr();
+        uint max_det = objects.cols / sizeof(Detection);
 
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, objects, ctr);
+        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr);
 
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index ecd1886d3..35658892f 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -47,11 +47,11 @@
 #include <opencv2/gpu/device/common.hpp>
 #include <stdio.h>
 
-// #if defined __CUDACC__
-// # define __device __device__ __forceinline__
-// #else
-// # define __device
-// #endif
+#if defined __CUDACC__
+# define __device __device__ __forceinline__
+#else
+# define __device
+#endif
 
 
 namespace cv { namespace gpu { namespace device {
@@ -108,66 +108,21 @@ struct __align__(8) Node
     }
 };
 
-// struct __align__(8) Feature
-// {
-//     int channel;
-//     uchar4 rect;
+struct __align__(16) Detection
+{
+    ushort x;
+    ushort y;
+    ushort w;
+    ushort h;
+    float confidence;
+    int kind;
+
+    Detection(){}
+    __device Detection(int _x, int _y, uchar _w, uchar _h, float c)
+    : x(_x), y(_y), w(_w), h(_h), confidence(c), kind(0) {};
+};
 
-//     Feature(const int c, const uchar4 r) : channel(c), rect(r) {}
-// };
 }
 }}}
-// struct Cascade
-// {
-//     Cascade() {}
-//     Cascade(const cv::gpu::PtrStepSzb& octs, const cv::gpu::PtrStepSzf& sts, const cv::gpu::PtrStepSzb& nds,
-//         const cv::gpu::PtrStepSzf& lvs, const cv::gpu::PtrStepSzb& fts, const cv::gpu::PtrStepSzb& lls)
-//     : octaves(octs), stages(sts), nodes(nds), leaves(lvs), features(fts), levels(lls) {}
-
-//     void detect(const cv::gpu::PtrStepSzi& hogluv, cv::gpu::PtrStepSz<uchar4> objects, cudaStream_t stream) const;
-//     void __device detectAt(const int* __restrict__ hogluv, const int pitch, PtrStepSz<uchar4>& objects) const;
-//     float __device rescale(const icf::Level& level, uchar4& scaledRect,
-//                            const int channel, const float threshold) const;
-
-//     PtrStepSzb octaves;
-//     PtrStepSzf stages;
-//     PtrStepSzb nodes;
-//     PtrStepSzf leaves;
-//     PtrStepSzb features;
-
-//     PtrStepSzb levels;
-
-// };
-
-// struct ChannelStorage
-// {
-//     ChannelStorage(){}
-//     ChannelStorage(const cv::gpu::PtrStepSzb& buff, const cv::gpu::PtrStepSzb& shr,
-//         const cv::gpu::PtrStepSzb& itg, const int s)
-//     : dmem (buff), shrunk(shr), hogluv(itg), shrinkage(s) {}
-
-//     void frame(const cv::gpu::PtrStepSz<uchar3>& rgb, cudaStream_t stream){}
-
-//     PtrStepSzb dmem;
-//     PtrStepSzb shrunk;
-//     PtrStepSzb hogluv;
-
-//     enum
-//     {
-//         FRAME_WIDTH        = 640,
-//         FRAME_HEIGHT       = 480,
-//         TOTAL_SCALES       = 55,
-//         CLASSIFIERS        = 5,
-//         ORIG_OBJECT_WIDTH  = 64,
-//         ORIG_OBJECT_HEIGHT = 128,
-//         HOG_BINS           = 6,
-//         HOG_LUV_BINS       = 10
-//     };
-
-//     int shrinkage;
-//     static const float magnitudeScaling = 1.f ;// / sqrt(2);
-// };
-
-// }}}
 
 #endif
\ No newline at end of file

From 612a258506aec30531e3db9dd1157253a6a4bc23 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 28 Sep 2012 19:10:29 +0400
Subject: [PATCH 028/155] kepler specific version

---
 modules/gpu/src/cuda/isf-sc.cu | 130 ++++++++++++++++++++++++---------
 1 file changed, 97 insertions(+), 33 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index adfc9edcb..f3c92cc6a 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -91,9 +91,9 @@ namespace icf {
         float relScale = level.relScale;
         float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
-        dprintf("feature %d box %d %d %d %d\n", (node.threshold >> 28), scaledRect.x, scaledRect.y,
+        dprintf("%d: feature %d box %d %d %d %d\n",threadIdx.x, (node.threshold >> 28), scaledRect.x, scaledRect.y,
             scaledRect.z, scaledRect.w);
-        dprintf("rescale: %f [%f %f] selected %f\n",level.relScale, level.scaling[0], level.scaling[1],
+        dprintf("%d: rescale: %f [%f %f] selected %f\n",threadIdx.x, level.relScale, level.scaling[0], level.scaling[1],
             level.scaling[(node.threshold >> 28) > 6]);
 
         // rescale
@@ -107,13 +107,13 @@ namespace icf {
         const float expected_new_area = farea * relScale * relScale;
         float approx =  sarea / expected_new_area;
 
-        dprintf("new rect: %d box %d %d %d %d  rel areas %f %f\n", (node.threshold >> 28),
+        dprintf("%d: new rect: %d box %d %d %d %d  rel areas %f %f\n",threadIdx.x, (node.threshold >> 28),
         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
 
         float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
         rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
 
-        dprintf("approximation %f %d -> %f %f\n", approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
+        dprintf("%d: approximation %f %d -> %f %f\n",threadIdx.x, approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
             level.scaling[(node.threshold >> 28) > 6]);
 
         return rootThreshold;
@@ -122,73 +122,137 @@ namespace icf {
     __device__ __forceinline__ int get(const int x, int y, uchar4 area)
     {
 
-        dprintf("feature box %d %d %d %d ", area.x, area.y, area.z, area.w);
-        dprintf("extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",
+        dprintf("%d: feature box %d %d %d %d\n",threadIdx.x, area.x, area.y, area.z, area.w);
+        dprintf("%d: extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",threadIdx.x,
             x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
             x + area.x, y + area.w);
-        dprintf("at point %d %d with offset %d\n", x, y, 0);
+        dprintf("%d: at point %d %d with offset %d\n", x, y, 0);
 
         int a = tex2D(thogluv, x + area.x, y + area.y);
         int b = tex2D(thogluv, x + area.z, y + area.y);
         int c = tex2D(thogluv, x + area.z, y + area.w);
         int d = tex2D(thogluv, x + area.x, y + area.w);
 
-        dprintf("    retruved integral values: %d %d %d %d\n", a, b, c, d);
+        dprintf("%d   retruved integral values: %d %d %d %d\n",threadIdx.x, a, b, c, d);
 
         return (a - b + c - d);
     }
 
-    __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
+//     __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
+//         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr)
+//     {
+//         const int y = blockIdx.y * blockDim.y + threadIdx.y;
+//         const int x = blockIdx.x * blockDim.x + threadIdx.x;
+//         Level level = levels[blockIdx.z];
+
+//         // if (blockIdx.z != 31) return;
+//         if(x >= level.workRect.x || y >= level.workRect.y) return;
+
+//         Octave octave = octaves[level.octave];
+
+//         int st = octave.index * octave.stages;
+//         const int stEnd = st + 1000;//octave.stages;
+
+//         float confidence = 0.f;
+
+// // #pragma unroll 2
+//         for(; st < stEnd; ++st)
+//         {
+//             dprintf("\n\nstage: %d\n", st);
+//             const int nId = st * 3;
+//             Node node = nodes[nId];
+
+//             dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
+//                 node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
+
+//             float threshold = rescale(level, node.rect, node);
+//             int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+
+//             dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
+//                 node.rect.w, threshold);
+
+//             int next = 1 + (int)(sum >= threshold);
+//             dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
+
+//             node = nodes[nId + next];
+//             threshold = rescale(level, node.rect, node);
+//             sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+
+//             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+//             float impact = leaves[st * 4 + lShift];
+//             confidence += impact;
+
+//             if (confidence <= stages[st]) st = stEnd + 10;
+//             dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+//             dprintf("extracted stage: %f\n", stages[st]);
+//             dprintf("computed  score: %f\n\n", confidence);
+//         }
+
+//         if(st == stEnd)
+//         {
+//             int idx = atomicInc(ctr, ndetections);
+//             // store detection
+//             objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
+//                 __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
+//         }
+//     }
+
+    __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr)
     {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int x = blockIdx.x;
+
         Level level = levels[blockIdx.z];
 
-        // if (blockIdx.z != 31) return;
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
         Octave octave = octaves[level.octave];
-
         int st = octave.index * octave.stages;
-        const int stEnd = st + 1000;//octave.stages;
+        const int stEnd = st + 1024;
 
         float confidence = 0.f;
 
-// #pragma unroll 2
-        for(; st < stEnd; ++st)
+        for(; st < stEnd; st += 32)
         {
-            dprintf("\n\nstage: %d\n", st);
-            const int nId = st * 3;
-            Node node = nodes[nId];
 
-            dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
-                node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
+            const int nId = (st + threadIdx.x) * 3;
+            dprintf("\n\n%d: stage: %d %d\n",threadIdx.x, st, nId);
+            Node node = nodes[nId];
 
             float threshold = rescale(level, node.rect, node);
             int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
 
-            dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
-                node.rect.w, threshold);
-
             int next = 1 + (int)(sum >= threshold);
-            dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
+            dprintf("%d: go: %d (%d >= %f)\n\n" ,threadIdx.x, next, sum, threshold);
 
             node = nodes[nId + next];
             threshold = rescale(level, node.rect, node);
             sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-            float impact = leaves[st * 4 + lShift];
-            confidence += impact;
+            float impact = leaves[(st + threadIdx.x) * 4 + lShift];
 
-            if (confidence <= stages[st]) st = stEnd + 10;
-            dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-            dprintf("extracted stage: %f\n", stages[st]);
-            dprintf("computed  score: %f\n\n", confidence);
+            dprintf("%d: decided: %d (%d >= %f) %d %f\n\n" ,threadIdx.x, next, sum, threshold, lShift, impact);
+            dprintf("%d: extracted stage: %f\n",threadIdx.x, stages[(st + threadIdx.x)]);
+            dprintf("%d: computed  score: %f\n",threadIdx.x, impact);
+
+            // scan on shuffl functions
+            for (int i = 1; i < 32; i *= 2)
+            {
+                const float n = __shfl_up(impact, i, 32);
+
+                if (threadIdx.x >= i)
+                    impact += n;
+            }
+
+            dprintf("%d: impact scaned %f\n" ,threadIdx.x, impact);
+
+            confidence += impact;
+            if(__any((confidence <= stages[(st + threadIdx.x)]))) break;
         }
 
-        if(st == stEnd)
+        if(st == stEnd && !threadIdx.x)
         {
             int idx = atomicInc(ctr, ndetections);
             // store detection
@@ -205,7 +269,7 @@ namespace icf {
         int fh = 120;
 
         dim3 block(32, 8);
-        dim3 grid(fw / 32, fh / 8, 47);
+        dim3 grid(fw, fh / 8, 47);
 
         const Level* l = (const Level*)levels.ptr();
         const Octave* oct = ((const Octave*)octaves.ptr());
@@ -219,7 +283,7 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr);
+        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr);
 
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());

From b52fea7fae6ec38096dcd57458e0ee6be87da996 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 1 Oct 2012 13:48:16 +0400
Subject: [PATCH 029/155] update soft cascade interface:  - add class Detection
 in interface,  - split sync- and async- versions,  - add support for
 detecting at the specific scale.

---
 modules/gpu/include/opencv2/gpu/gpu.hpp | 26 ++++++++++++-
 modules/gpu/src/cuda/isf-sc.cu          | 45 ++++++++++++++++++----
 modules/gpu/src/softcascade.cpp         | 50 ++++++++++++++++++++-----
 3 files changed, 103 insertions(+), 18 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 5008e1027..f171ad904 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1537,6 +1537,18 @@ public:
 class CV_EXPORTS SoftCascade
 {
 public:
+
+    struct CV_EXPORTS Detection
+    {
+        ushort x;
+        ushort y;
+        ushort w;
+        ushort h;
+        float confidence;
+        int kind;
+
+        enum {PEDESTRIAN = 0};
+    };
     //! An empty cascade will be created.
     SoftCascade();
 
@@ -1559,9 +1571,19 @@ public:
     //! Param rois is a mask
     //! Param objects 4-channel matrix thet contain detected rectangles
     //! Param rejectfactor used for final object box computing
-    //! Param stream
     virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor = 1, Stream stream = Stream::Null());
+    int rejectfactor = 1, int specificScale = -1);
+
+    //! detect specific objects on in the input frame for all scales computed flom minScale and maxscale values.
+    //! asynchronous version.
+    //! Param image is input frame for detector. Cascade will be applied to it.
+    //! Param rois is a mask
+    //! Param objects 4-channel matrix thet contain detected rectangles
+    //! Param rejectfactor used for final object box computing
+    //! Param ndet retrieves number of detections
+    //! Param stream wrapper for CUDA stream
+    virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
+    int rejectfactor, GpuMat& ndet, Stream stream);
 
 private:
     struct Filds;
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index f3c92cc6a..3d9a1e10f 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -105,7 +105,7 @@ namespace icf {
         float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
         const float expected_new_area = farea * relScale * relScale;
-        float approx =  sarea / expected_new_area;
+        float approx = __fdividef(sarea, expected_new_area);
 
         dprintf("%d: new rect: %d box %d %d %d %d  rel areas %f %f\n",threadIdx.x, (node.threshold >> 28),
         scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
@@ -198,12 +198,13 @@ namespace icf {
 //     }
 
     __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr)
+        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
+        const int downscales)
     {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x;
 
-        Level level = levels[blockIdx.z];
+        Level level = levels[downscales + blockIdx.z];
 
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
@@ -236,7 +237,7 @@ namespace icf {
             dprintf("%d: decided: %d (%d >= %f) %d %f\n\n" ,threadIdx.x, next, sum, threshold, lShift, impact);
             dprintf("%d: extracted stage: %f\n",threadIdx.x, stages[(st + threadIdx.x)]);
             dprintf("%d: computed  score: %f\n",threadIdx.x, impact);
-
+#pragma unroll
             // scan on shuffl functions
             for (int i = 1; i < 32; i *= 2)
             {
@@ -263,13 +264,13 @@ namespace icf {
 
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
                 const PtrStepSzb& nodes,  const PtrStepSzf& leaves,  const PtrStepSzi& hogluv,
-                PtrStepSz<uchar4> objects, PtrStepSzi counter)
+                PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales)
     {
         int fw = 160;
         int fh = 120;
 
         dim3 block(32, 8);
-        dim3 grid(fw, fh / 8, 47);
+        dim3 grid(fw, fh / 8, downscales);
 
         const Level* l = (const Level*)levels.ptr();
         const Octave* oct = ((const Octave*)octaves.ptr());
@@ -283,8 +284,38 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr);
+        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
+        cudaSafeCall( cudaGetLastError());
 
+        grid = dim3(fw, fh / 8, 47 - downscales);
+        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, downscales);
+        cudaSafeCall( cudaGetLastError());
+        cudaSafeCall( cudaDeviceSynchronize());
+    }
+
+    void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
+        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
+        PtrStepSzi counter)
+    {
+        int fw = 160;
+        int fh = 120;
+
+        dim3 block(32, 8);
+        dim3 grid(fw, fh / 8, 1);
+
+        const Level* l = (const Level*)levels.ptr();
+        const Octave* oct = ((const Octave*)octaves.ptr());
+        const float* st = (const float*)stages.ptr();
+        const Node* nd = (const Node*)nodes.ptr();
+        const float* lf = (const float*)leaves.ptr();
+        uint* ctr = (uint*)counter.ptr();
+        Detection* det = (Detection*)objects.ptr();
+        uint max_det = objects.cols / sizeof(Detection);
+
+        cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
+        cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
+
+        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
     }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 320fbb343..fd94909cf 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -49,7 +49,11 @@ cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
 bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); return false; }
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, Stream) { throw_nogpu();}
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, int) { throw_nogpu();}
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream)
+{
+    throw_nogpu();
+}
 
 #else
 
@@ -60,6 +64,9 @@ namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
+        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
+        PtrStepSzi counter, const int downscales);
+    void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
         const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
         PtrStepSzi counter);
 }
@@ -86,6 +93,8 @@ struct cv::gpu::SoftCascade::Filds
     int origObjWidth;
     int origObjHeight;
 
+    int downscales;
+
     GpuMat octaves;
     GpuMat stages;
     GpuMat nodes;
@@ -120,7 +129,6 @@ struct cv::gpu::SoftCascade::Filds
         FRAME_WIDTH        = 640,
         FRAME_HEIGHT       = 480,
         TOTAL_SCALES       = 55,
-//         CLASSIFIERS        = 5,
         ORIG_OBJECT_WIDTH  = 64,
         ORIG_OBJECT_HEIGHT = 128,
         HOG_BINS           = 6,
@@ -132,7 +140,14 @@ struct cv::gpu::SoftCascade::Filds
     void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter);
+        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter, downscales);
+    }
+
+    void detectAtScale(int scale, cv::gpu::GpuMat objects, cudaStream_t stream) const
+    {
+        cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
+        device::icf::detectAtScale(scale, levels, octaves, stages, nodes, leaves, hogluv, objects,
+            detCounter);
     }
 
 private:
@@ -160,7 +175,7 @@ private:
     }
 };
 
-inline bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
+bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
 {
     using namespace device::icf;
     minScale = mins;
@@ -351,6 +366,7 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<device::ic
     float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
 
     float scale = minScale;
+    downscales = 0;
     for (int sc = 0; sc < nscales; ++sc)
     {
         int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
@@ -366,7 +382,10 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<device::ic
         if (!width || !height)
             break;
         else
+        {
             vlevels.push_back(level);
+            if (octs[fit].scale < 1) ++downscales;
+        }
 
         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
@@ -424,8 +443,11 @@ namespace {
         return s;
     }
 }
+
+//================================== synchronous version ============================================================//
+
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
-                                GpuMat& objects, const int /*rejectfactor*/, Stream s)
+                                GpuMat& objects, const int /*rejectfactor*/, int specificScale)
 {
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3);
@@ -513,11 +535,21 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     }
 #endif
 
-    cudaStream_t stream = StreamAccessor::getStream(s);
-    flds.detect(objects, stream);
+    if (specificScale == -1)
+        flds.detect(objects, 0);
+    else
+        flds.detectAtScale(specificScale, objects, 0);
 
-        //     cv::Mat out(flds.detCounter);
-        // std::cout << out << std::endl;
+    cv::Mat out(flds.detCounter);
+    int ndetections = *(out.data);
+
+    objects = GpuMat(objects, cv::Rect(0, 0, ndetections * sizeof(Detection), 1));
 }
 
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream)
+{
+    // cudaStream_t stream = StreamAccessor::getStream(s);
+}
+
+
 #endif
\ No newline at end of file

From 7db1323f81fbc9b3de83c6127a36275470060e6b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 1 Oct 2012 13:49:21 +0400
Subject: [PATCH 030/155] add test that stores detections on the specific scale

---
 modules/gpu/test/test_softcascade.cpp | 59 +++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index c7e3a1f77..0da07298d 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -71,4 +71,63 @@ TEST(SoftCascade, detect)
     // });
 }
 
+class SCSpecific : public ::testing::TestWithParam<std::tr1::tuple<std::string, int> > {
+};
+
+namespace {
+std::string itoa(long i)
+{
+    static char s[65];
+    sprintf(s, "%ld", i);
+    return std::string(s);
+}
+}
+
+TEST_P(SCSpecific, detect)
+{
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(xml));
+
+    std::string path = GET_PARAM(0);
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + path);
+
+    ASSERT_FALSE(coloredCpu.empty());
+    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois;
+
+    int level = GET_PARAM(1);
+    cascade.detectMultiScale(colored, rois, objectBoxes, 1, level);
+
+    cv::Mat dt(objectBoxes);
+    typedef cv::gpu::SoftCascade::Detection detection_t;
+
+    detection_t* dts = (detection_t*)dt.data;
+    cv::Mat result(coloredCpu);
+
+
+    std::cout << "Total detections " << (dt.cols / sizeof(detection_t)) << std::endl;
+    for(int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
+    {
+        detection_t d = dts[i];
+        std::cout << "detection: [" << std::setw(4) << d.x << " " << std::setw(4) << d.y
+                  << "] [" << std::setw(4) << d.w << " " << std::setw(4) << d.h << "] "
+                  << std::setw(12)  << d.confidence << std::endl;
+
+        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+    }
+
+    std::cout << "Result stored in " << "/home/kellan/gpu_res_1_oct_" + itoa(level) << "_"
+    + itoa((dt.cols / sizeof(detection_t))) + ".png" << std::endl;
+    cv::imwrite("/home/kellan/gpu_res_1_oct_" + itoa(level) + "_" + itoa((dt.cols / sizeof(detection_t))) + ".png",
+        result);
+    cv::imshow("res", result);
+    cv::waitKey(0);
+}
+
+INSTANTIATE_TEST_CASE_P(inLevel, SCSpecific,
+    testing::Combine(
+        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 47)
+        ));
+
 #endif
\ No newline at end of file

From 56c7ef06e7a5e40e65c6a4d14775aa8defbc2dfb Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 1 Oct 2012 14:08:48 +0400
Subject: [PATCH 031/155] integrate Kepler version

---
 modules/gpu/src/cuda/isf-sc.cu | 120 +++++++++++++++++----------------
 1 file changed, 61 insertions(+), 59 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 3d9a1e10f..cc4502494 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -138,65 +138,7 @@ namespace icf {
         return (a - b + c - d);
     }
 
-//     __global__ void test_kernel(const Level* levels, const Octave* octaves, const float* stages,
-//         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr)
-//     {
-//         const int y = blockIdx.y * blockDim.y + threadIdx.y;
-//         const int x = blockIdx.x * blockDim.x + threadIdx.x;
-//         Level level = levels[blockIdx.z];
-
-//         // if (blockIdx.z != 31) return;
-//         if(x >= level.workRect.x || y >= level.workRect.y) return;
-
-//         Octave octave = octaves[level.octave];
-
-//         int st = octave.index * octave.stages;
-//         const int stEnd = st + 1000;//octave.stages;
-
-//         float confidence = 0.f;
-
-// // #pragma unroll 2
-//         for(; st < stEnd; ++st)
-//         {
-//             dprintf("\n\nstage: %d\n", st);
-//             const int nId = st * 3;
-//             Node node = nodes[nId];
-
-//             dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
-//                 node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
-
-//             float threshold = rescale(level, node.rect, node);
-//             int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
-
-//             dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
-//                 node.rect.w, threshold);
-
-//             int next = 1 + (int)(sum >= threshold);
-//             dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
-
-//             node = nodes[nId + next];
-//             threshold = rescale(level, node.rect, node);
-//             sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
-
-//             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-//             float impact = leaves[st * 4 + lShift];
-//             confidence += impact;
-
-//             if (confidence <= stages[st]) st = stEnd + 10;
-//             dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-//             dprintf("extracted stage: %f\n", stages[st]);
-//             dprintf("computed  score: %f\n\n", confidence);
-//         }
-
-//         if(st == stEnd)
-//         {
-//             int idx = atomicInc(ctr, ndetections);
-//             // store detection
-//             objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
-//                 __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
-//         }
-//     }
-
+#if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
     __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
         const int downscales)
@@ -261,6 +203,66 @@ namespace icf {
                 __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
         }
     }
+#else
+    __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
+        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
+        const int downscales)
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        Level level = levels[blockIdx.z];
+
+        // if (blockIdx.z != 31) return;
+        if(x >= level.workRect.x || y >= level.workRect.y) return;
+
+        Octave octave = octaves[level.octave];
+
+        int st = octave.index * octave.stages;
+        const int stEnd = st + 1000;//octave.stages;
+
+        float confidence = 0.f;
+
+        for(; st < stEnd; ++st)
+        {
+            dprintf("\n\nstage: %d\n", st);
+            const int nId = st * 3;
+            Node node = nodes[nId];
+
+            dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
+                node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
+
+            float threshold = rescale(level, node.rect, node);
+            int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+
+            dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
+                node.rect.w, threshold);
+
+            int next = 1 + (int)(sum >= threshold);
+            dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
+
+            node = nodes[nId + next];
+            threshold = rescale(level, node.rect, node);
+            sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+
+            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+            float impact = leaves[st * 4 + lShift];
+            confidence += impact;
+
+            if (confidence <= stages[st]) st = stEnd + 10;
+            dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
+            dprintf("extracted stage: %f\n", stages[st]);
+            dprintf("computed  score: %f\n\n", confidence);
+        }
+
+        if(st == stEnd)
+        {
+            int idx = atomicInc(ctr, ndetections);
+            // store detection
+            objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
+                __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
+        }
+    }
+#endif
 
     void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
                 const PtrStepSzb& nodes,  const PtrStepSzf& leaves,  const PtrStepSzi& hogluv,

From 672cf1f44576bb82f1202c0c15c947b47469304b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 1 Oct 2012 14:50:28 +0400
Subject: [PATCH 032/155] implement different behaviour for up- and
 down-scaling

---
 modules/gpu/src/cuda/isf-sc.cu        | 98 +++++++++++++++++++++++----
 modules/gpu/src/softcascade.cpp       | 13 +++-
 modules/gpu/test/test_softcascade.cpp |  2 +-
 3 files changed, 95 insertions(+), 18 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index cc4502494..c9a92e379 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -86,8 +86,11 @@ namespace icf {
     }
 
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
-    __device__ __forceinline__ float rescale(const Level& level, uchar4& scaledRect, const Node& node)
+
+    template<bool isUp>
+    __device__ __forceinline__ float rescale(const Level& level, Node& node)
     {
+        uchar4& scaledRect = node.rect;
         float relScale = level.relScale;
         float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
@@ -119,7 +122,44 @@ namespace icf {
         return rootThreshold;
     }
 
-    __device__ __forceinline__ int get(const int x, int y, uchar4 area)
+    template<>
+    __device__ __forceinline__ float rescale<true>(const Level& level, Node& node)
+    {
+        uchar4& scaledRect = node.rect;
+        float relScale = level.relScale;
+        float farea = scaledRect.z * scaledRect.w;
+
+        dprintf("%d: feature %d box %d %d %d %d\n",threadIdx.x, (node.threshold >> 28), scaledRect.x, scaledRect.y,
+            scaledRect.z, scaledRect.w);
+        dprintf("%d: rescale: %f [%f %f] selected %f\n",threadIdx.x, level.relScale, level.scaling[0], level.scaling[1],
+            level.scaling[(node.threshold >> 28) > 6]);
+
+        // rescale
+        scaledRect.x = __float2int_rn(relScale * scaledRect.x);
+        scaledRect.y = __float2int_rn(relScale * scaledRect.y);
+        scaledRect.z = __float2int_rn(relScale * scaledRect.z);
+        scaledRect.w = __float2int_rn(relScale * scaledRect.w);
+
+        float sarea = scaledRect.z * scaledRect.w;
+
+        const float expected_new_area = farea * relScale * relScale;
+        float approx = __fdividef(sarea, expected_new_area);
+
+        dprintf("%d: new rect: %d box %d %d %d %d  rel areas %f %f\n",threadIdx.x, (node.threshold >> 28),
+        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
+
+        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
+
+        rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
+
+        dprintf("%d: approximation %f %d -> %f %f\n",threadIdx.x, approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
+            level.scaling[(node.threshold >> 28) > 6]);
+
+        return rootThreshold;
+    }
+
+    template<bool isUp>
+    __device__ __forceinline__ int get(int x, int y, uchar4 area)
     {
 
         dprintf("%d: feature box %d %d %d %d\n",threadIdx.x, area.x, area.y, area.z, area.w);
@@ -138,7 +178,30 @@ namespace icf {
         return (a - b + c - d);
     }
 
+    template<>
+    __device__ __forceinline__ int get<true>(int x, int y, uchar4 area)
+    {
+
+        dprintf("%d: feature box %d %d %d %d\n",threadIdx.x, area.x, area.y, area.z, area.w);
+        dprintf("%d: extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",threadIdx.x,
+            x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
+            x + area.x, y + area.w);
+        dprintf("%d: at point %d %d with offset %d\n", x, y, 0);
+
+        x += area.x;
+        y += area.y;
+        int a = tex2D(thogluv, x, y);
+        int b = tex2D(thogluv, x + area.z, y);
+        int c = tex2D(thogluv, x + area.z, y + area.w);
+        int d = tex2D(thogluv, x, y + area.w);
+
+        dprintf("%d   retruved integral values: %d %d %d %d\n",threadIdx.x, a, b, c, d);
+
+        return (a - b + c - d);
+    }
+
 #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
+    template<bool isUp>
     __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
         const int downscales)
@@ -163,15 +226,15 @@ namespace icf {
             dprintf("\n\n%d: stage: %d %d\n",threadIdx.x, st, nId);
             Node node = nodes[nId];
 
-            float threshold = rescale(level, node.rect, node);
-            int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+            float threshold = rescale<isUp>(level, node);
+            int sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
 
             int next = 1 + (int)(sum >= threshold);
             dprintf("%d: go: %d (%d >= %f)\n\n" ,threadIdx.x, next, sum, threshold);
 
             node = nodes[nId + next];
-            threshold = rescale(level, node.rect, node);
-            sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+            threshold = rescale<isUp>(level, node);
+            sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
             float impact = leaves[(st + threadIdx.x) * 4 + lShift];
@@ -192,7 +255,7 @@ namespace icf {
             dprintf("%d: impact scaned %f\n" ,threadIdx.x, impact);
 
             confidence += impact;
-            if(__any((confidence <= stages[(st + threadIdx.x)]))) break;
+            if(__any((confidence <= stages[(st + threadIdx.x)]))) st += stEnd;
         }
 
         if(st == stEnd && !threadIdx.x)
@@ -204,6 +267,7 @@ namespace icf {
         }
     }
 #else
+    template<bool isUp>
     __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
         const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
         const int downscales)
@@ -231,8 +295,8 @@ namespace icf {
             dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
                 node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
 
-            float threshold = rescale(level, node.rect, node);
-            int sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+            float threshold = rescale<isUp>(level, node);
+            int sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
 
             dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
                 node.rect.w, threshold);
@@ -241,8 +305,8 @@ namespace icf {
             dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
 
             node = nodes[nId + next];
-            threshold = rescale(level, node.rect, node);
-            sum = get(x, y + (node.threshold >> 28) * 121, node.rect);
+            threshold = rescale<isUp>(level, node);
+            sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
             float impact = leaves[st * 4 + lShift];
@@ -286,18 +350,18 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
+        test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
         cudaSafeCall( cudaGetLastError());
 
         grid = dim3(fw, fh / 8, 47 - downscales);
-        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, downscales);
+        test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, downscales);
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
     }
 
     void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
         const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter)
+        PtrStepSzi counter, const int downscales)
     {
         int fw = 160;
         int fh = 120;
@@ -317,7 +381,11 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        test_kernel_warp<<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
+        if (scale >= downscales)
+            test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
+        else
+            test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
+
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
     }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index fd94909cf..8868aa5b1 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -68,7 +68,7 @@ namespace icf {
         PtrStepSzi counter, const int downscales);
     void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
         const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter);
+        PtrStepSzi counter, const int downscales);
 }
 }}}
 
@@ -147,7 +147,7 @@ struct cv::gpu::SoftCascade::Filds
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
         device::icf::detectAtScale(scale, levels, octaves, stages, nodes, leaves, hogluv, objects,
-            detCounter);
+            detCounter, downscales);
     }
 
 private:
@@ -240,6 +240,9 @@ bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, c
     {
         FileNode fns = *it;
         float scale = (float)fns[SC_OCT_SCALE];
+
+        bool isUPOctave = scale >= 1;
+
         scales.push_back(scale);
         ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
         ushort2 size;
@@ -286,6 +289,12 @@ bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, c
                     rect.z = saturate_cast<uchar>((int)*(r_it++));
                     rect.w = saturate_cast<uchar>((int)*(r_it++));
 
+                    if (isUPOctave)
+                    {
+                        rect.z -= rect.x;
+                        rect.w -= rect.y;
+                    }
+
                     uint channel = saturate_cast<uint>((int)(*ftrs)[SC_F_CHANNEL]);
                     vnodes.push_back(Node(rect, channel, th));
                     ++ftrs;
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 0da07298d..4d1a4b7a6 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -63,7 +63,7 @@ TEST(SoftCascade, detect)
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
         + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
-    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois;
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois;
 
     // ASSERT_NO_THROW(
     // {

From 64d6e6a48d4580964a8ce8b589a94e973804c3b9 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Tue, 2 Oct 2012 16:45:40 +0400
Subject: [PATCH 033/155] add getROISize

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  6 ++++--
 modules/gpu/src/softcascade.cpp         | 21 ++++++++++++++++-----
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index f171ad904..9b59c6004 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1572,7 +1572,7 @@ public:
     //! Param objects 4-channel matrix thet contain detected rectangles
     //! Param rejectfactor used for final object box computing
     virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor = 1, int specificScale = -1);
+    int rejectfactor = 1, int specificScale = -1) const;
 
     //! detect specific objects on in the input frame for all scales computed flom minScale and maxscale values.
     //! asynchronous version.
@@ -1583,7 +1583,9 @@ public:
     //! Param ndet retrieves number of detections
     //! Param stream wrapper for CUDA stream
     virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor, GpuMat& ndet, Stream stream);
+    int rejectfactor, GpuMat& ndet, Stream stream) const;
+
+    cv::Size getRoiSize() const;
 
 private:
     struct Filds;
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 8868aa5b1..af836695a 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -49,12 +49,18 @@ cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
 cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
 bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); return false; }
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, int) { throw_nogpu();}
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream)
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, int) const
 {
     throw_nogpu();
 }
 
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream) const
+{
+    throw_nogpu();
+}
+
+cv::Size cv::gpu::SoftCascade::getRoiSize() const { throw_nogpu(); return cv::Size();}
+
 #else
 
 #include <icf.hpp>
@@ -455,8 +461,8 @@ namespace {
 
 //================================== synchronous version ============================================================//
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& /*rois*/,
-                                GpuMat& objects, const int /*rejectfactor*/, int specificScale)
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& rois,
+                                GpuMat& objects, const int /*rejectfactor*/, int specificScale) const
 {
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3);
@@ -555,10 +561,15 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     objects = GpuMat(objects, cv::Rect(0, 0, ndetections * sizeof(Detection), 1));
 }
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream)
+void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream) const
 {
     // cudaStream_t stream = StreamAccessor::getStream(s);
 }
 
+cv::Size cv::gpu::SoftCascade::getRoiSize() const
+{
+    return cv::Size(Filds::FRAME_WIDTH / 4, Filds::FRAME_HEIGHT / 4);
+}
+
 
 #endif
\ No newline at end of file

From eb91593c08daca478663d7d0805f0ce664fd5d9b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Tue, 2 Oct 2012 17:25:26 +0400
Subject: [PATCH 034/155] add roi support

---
 modules/gpu/perf/perf_objdetect.cpp   |  6 +++-
 modules/gpu/src/cuda/isf-sc.cu        | 21 ++++++++++---
 modules/gpu/src/softcascade.cpp       | 44 +++++++++++++++++++--------
 modules/gpu/test/test_softcascade.cpp | 16 ++++++----
 4 files changed, 64 insertions(+), 23 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 8531372b0..a86337112 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -104,7 +104,11 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
         cv::gpu::SoftCascade cascade;
         ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
 
-        cv::gpu::GpuMat rois, objectBoxes(1, 16384, CV_8UC1);
+        cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+
+        rois.setTo(0);
+        cv::gpu::GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+        sub.setTo(cv::Scalar::all(1));
         cascade.detectMultiScale(colored, rois, objectBoxes);
 
         TEST_CYCLE()
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index c9a92e379..4bde7f7ea 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -86,6 +86,7 @@ namespace icf {
     }
 
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
+    texture<char,  cudaTextureType2D, cudaReadModeElementType> troi;
 
     template<bool isUp>
     __device__ __forceinline__ float rescale(const Level& level, Node& node)
@@ -213,6 +214,8 @@ namespace icf {
 
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
+        if (!tex2D(troi, x, y)) return;
+
         Octave octave = octaves[level.octave];
         int st = octave.index * octave.stages;
         const int stEnd = st + 1024;
@@ -279,6 +282,10 @@ namespace icf {
         // if (blockIdx.z != 31) return;
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
+        int roi = tex2D(troi, x, y);
+        printf("%d\n", roi);
+        if (!roi) return;
+
         Octave octave = octaves[level.octave];
 
         int st = octave.index * octave.stages;
@@ -328,7 +335,7 @@ namespace icf {
     }
 #endif
 
-    void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
+    void detect(const PtrStepSzb& roi, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
                 const PtrStepSzb& nodes,  const PtrStepSzf& leaves,  const PtrStepSzi& hogluv,
                 PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales)
     {
@@ -350,6 +357,9 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
+        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<char>();
+        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols, roi.rows, roi.step));
+
         test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
         cudaSafeCall( cudaGetLastError());
 
@@ -359,9 +369,9 @@ namespace icf {
         cudaSafeCall( cudaDeviceSynchronize());
     }
 
-    void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales)
+    void detectAtScale(const int scale, const PtrStepSzb& roi, const PtrStepSzb& levels, const PtrStepSzb& octaves,
+        const PtrStepSzf& stages, const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv,
+        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales)
     {
         int fw = 160;
         int fh = 120;
@@ -381,6 +391,9 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
+        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<char>();
+        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols, roi.rows, roi.step));
+
         if (scale >= downscales)
             test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
         else
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index af836695a..9ea365c5e 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -69,12 +69,29 @@ namespace cv { namespace gpu { namespace device {
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
-    void detect(const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales);
-    void detectAtScale(const int scale, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-        const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales);
+
+    void detect(const PtrStepSzb& rois,
+                const PtrStepSzb& levels,
+                const PtrStepSzb& octaves,
+                const PtrStepSzf& stages,
+                const PtrStepSzb& nodes,
+                const PtrStepSzf& leaves,
+                const PtrStepSzi& hogluv,
+                PtrStepSz<uchar4> objects,
+                PtrStepSzi counter,
+                const int downscales);
+
+    void detectAtScale(const int scale,
+                       const PtrStepSzb& rois,
+                       const PtrStepSzb& levels,
+                       const PtrStepSzb& octaves,
+                       const PtrStepSzf& stages,
+                       const PtrStepSzb& nodes,
+                       const PtrStepSzf& leaves,
+                       const PtrStepSzi& hogluv,
+                       PtrStepSz<uchar4> objects,
+                       PtrStepSzi counter,
+                       const int downscales);
 }
 }}}
 
@@ -143,16 +160,16 @@ struct cv::gpu::SoftCascade::Filds
     };
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(cv::gpu::GpuMat objects, cudaStream_t stream) const
+    void detect(cv::gpu::GpuMat roi, cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        device::icf::detect(levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter, downscales);
+        device::icf::detect(roi, levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter, downscales);
     }
 
-    void detectAtScale(int scale, cv::gpu::GpuMat objects, cudaStream_t stream) const
+    void detectAtScale(int scale, cv::gpu::GpuMat roi, cv::gpu::GpuMat objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        device::icf::detectAtScale(scale, levels, octaves, stages, nodes, leaves, hogluv, objects,
+        device::icf::detectAtScale(scale, roi, levels, octaves, stages, nodes, leaves, hogluv, objects,
             detCounter, downscales);
     }
 
@@ -467,6 +484,9 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3);
 
+    // we guess user knows about shrincage
+    CV_Assert((rois.size() == getRoiSize()) && (rois.type() == CV_8UC1));
+
     // only this window size allowed
     CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
 
@@ -551,9 +571,9 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 #endif
 
     if (specificScale == -1)
-        flds.detect(objects, 0);
+        flds.detect(rois,objects, 0);
     else
-        flds.detectAtScale(specificScale, objects, 0);
+        flds.detectAtScale(specificScale, rois, objects, 0);
 
     cv::Mat out(flds.detCounter);
     int ndetections = *(out.data);
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 4d1a4b7a6..84602915f 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -63,12 +63,13 @@ TEST(SoftCascade, detect)
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
         + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
-    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois;
 
-    // ASSERT_NO_THROW(
-    // {
-        cascade.detectMultiScale(colored, rois, objectBoxes);
-    // });
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
+
+    cascade.detectMultiScale(colored, rois, objectBoxes);
 }
 
 class SCSpecific : public ::testing::TestWithParam<std::tr1::tuple<std::string, int> > {
@@ -93,7 +94,10 @@ TEST_P(SCSpecific, detect)
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + path);
 
     ASSERT_FALSE(coloredCpu.empty());
-    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois;
+    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
 
     int level = GET_PARAM(1);
     cascade.detectMultiScale(colored, rois, objectBoxes, 1, level);

From dd595376ba861ce13f5015abc8297bd92bf5938c Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 3 Oct 2012 14:26:26 +0400
Subject: [PATCH 035/155] Add performance test for  detection in ROI; refactor
 soft cascade performance tests

---
 modules/gpu/test/test_softcascade.cpp | 248 +++++++++++++++++++-------
 1 file changed, 181 insertions(+), 67 deletions(-)

diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 84602915f..0b266f827 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -41,20 +41,197 @@
 //M*/
 
 #include <test_precomp.hpp>
+#include <time.h>
 
 #ifdef HAVE_CUDA
-
 using cv::gpu::GpuMat;
 
-TEST(SoftCascade, readCascade)
+// show detection results on input image with cv::imshow
+//#define SHOW_DETECTIONS
+
+#if defined SHOW_DETECTIONS
+# define SHOW(res)           \
+    cv::imshow(#res, result);\
+    cv::waitKey(0);
+#else
+# define SHOW(res)
+#endif
+
+#define GPU_TEST_P(fixture, name, params)                         \
+    class fixture##_##name : public fixture {                     \
+     public:                                                      \
+      fixture##_##name() {}                                       \
+     protected:                                                   \
+      virtual void body();                                        \
+    };                                                            \
+    TEST_P(fixture##_##name, name /*none*/){ body();}             \
+    INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);  \
+    void fixture##_##name::body()
+
+
+typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
+
+struct SoftCascadeTest : public ::testing::TestWithParam<roi_fixture_t>
+{
+    typedef cv::gpu::SoftCascade::Detection detection_t;
+    static cv::Rect getFromTable(int idx)
+    {
+        static const cv::Rect rois[] =
+        {
+            cv::Rect( 65,  20,  35, 80),
+            cv::Rect( 95,  35,  45, 40),
+            cv::Rect( 45,  35,  45, 40),
+            cv::Rect( 25,  27,  50, 45),
+            cv::Rect(100,  50,  45, 40),
+
+            cv::Rect( 60,  30,  45, 40),
+            cv::Rect( 40,  55,  50, 40),
+            cv::Rect( 48,  37,  72, 80),
+            cv::Rect( 48,  32,  85, 58),
+            cv::Rect( 48,   0,  32, 27)
+        };
+
+        return rois[idx];
+    }
+
+    static std::string itoa(long i)
+    {
+        static char s[65];
+        sprintf(s, "%ld", i);
+        return std::string(s);
+    }
+
+    static std::string getImageName(int level)
+    {
+        time_t rawtime;
+        struct tm * timeinfo;
+        char buffer [80];
+
+        time ( &rawtime );
+        timeinfo = localtime ( &rawtime );
+
+        strftime (buffer,80,"%Y-%m-%d--%H-%M-%S",timeinfo);
+        return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
+    }
+
+    static void print(std::ostream &out, const detection_t& d)
+    {
+        out << "\x1b[32m[ detection]\x1b[0m ("
+            << std::setw(4)  << d.x
+            << " "
+            << std::setw(4)  << d.y
+            << ") ("
+            << std::setw(4)  << d.w
+            << " "
+            << std::setw(4)  << d.h
+            << ") "
+            << std::setw(12) << d.confidence
+            <<  std::endl;
+    }
+
+    static void printTotal(std::ostream &out, int detbytes)
+    {
+        out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(detection_t)) << std::endl;
+    }
+
+    static void writeResult(const cv::Mat& result, const int level)
+    {
+        std::string path = cv::tempfile(getImageName(level).c_str());
+        cv::imwrite(path, result);
+        std::cout << "\x1b[32m" << "[          ]" << std::endl << "[ stored in]"<< "\x1b[0m" << path << std::endl;
+    }
+};
+
+GPU_TEST_P(SoftCascadeTest, detectInROI,
+    testing::Combine(
+        testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 5)))
+{
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1));
+    ASSERT_FALSE(coloredCpu.empty());
+
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(cvtest::TS::ptr()->get_data_path() + GET_PARAM(0)));
+
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(0);
+
+    int nroi = GET_PARAM(2);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
+    {
+        cv::Rect r = getFromTable(rng(10));
+        GpuMat sub(rois, r);
+        sub.setTo(1);
+    }
+
+    cascade.detectMultiScale(colored, rois, objectBoxes);
+
+    ///
+    cv::Mat dt(objectBoxes);
+    typedef cv::gpu::SoftCascade::Detection detection_t;
+
+    detection_t* dts = (detection_t*)dt.data;
+    cv::Mat result(coloredCpu);
+
+    printTotal(std::cout, dt.cols);
+    for (int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
+    {
+        detection_t d = dts[i];
+        print(std::cout, d);
+        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+    }
+
+    SHOW(result);
+}
+
+GPU_TEST_P(SoftCascadeTest, detectInLevel,
+        testing::Combine(
+        testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 47)
+        ))
+{
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + GET_PARAM(0);
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(xml));
+
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1));
+    ASSERT_FALSE(coloredCpu.empty());
+
+    typedef cv::gpu::SoftCascade::Detection detection_t;
+    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(detection_t), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(1);
+
+    int level = GET_PARAM(2);
+    cascade.detectMultiScale(colored, rois, objectBoxes, 1, level);
+
+    cv::Mat dt(objectBoxes);
+
+    detection_t* dts = (detection_t*)dt.data;
+    cv::Mat result(coloredCpu);
+
+    printTotal(std::cout, dt.cols);
+    for (int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
+    {
+        detection_t d = dts[i];
+        print(std::cout, d);
+        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+    }
+
+    writeResult(result, level);
+    SHOW(result);
+}
+
+TEST(SoftCascadeTest, readCascade)
 {
     std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
-
 }
 
-TEST(SoftCascade, detect)
+TEST(SoftCascadeTest, detect)
 {
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SoftCascade cascade;
@@ -71,67 +248,4 @@ TEST(SoftCascade, detect)
 
     cascade.detectMultiScale(colored, rois, objectBoxes);
 }
-
-class SCSpecific : public ::testing::TestWithParam<std::tr1::tuple<std::string, int> > {
-};
-
-namespace {
-std::string itoa(long i)
-{
-    static char s[65];
-    sprintf(s, "%ld", i);
-    return std::string(s);
-}
-}
-
-TEST_P(SCSpecific, detect)
-{
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(xml));
-
-    std::string path = GET_PARAM(0);
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + path);
-
-    ASSERT_FALSE(coloredCpu.empty());
-    GpuMat colored(coloredCpu), objectBoxes(1, 1000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
-    rois.setTo(0);
-    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-    sub.setTo(cv::Scalar::all(1));
-
-    int level = GET_PARAM(1);
-    cascade.detectMultiScale(colored, rois, objectBoxes, 1, level);
-
-    cv::Mat dt(objectBoxes);
-    typedef cv::gpu::SoftCascade::Detection detection_t;
-
-    detection_t* dts = (detection_t*)dt.data;
-    cv::Mat result(coloredCpu);
-
-
-    std::cout << "Total detections " << (dt.cols / sizeof(detection_t)) << std::endl;
-    for(int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
-    {
-        detection_t d = dts[i];
-        std::cout << "detection: [" << std::setw(4) << d.x << " " << std::setw(4) << d.y
-                  << "] [" << std::setw(4) << d.w << " " << std::setw(4) << d.h << "] "
-                  << std::setw(12)  << d.confidence << std::endl;
-
-        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
-    }
-
-    std::cout << "Result stored in " << "/home/kellan/gpu_res_1_oct_" + itoa(level) << "_"
-    + itoa((dt.cols / sizeof(detection_t))) + ".png" << std::endl;
-    cv::imwrite("/home/kellan/gpu_res_1_oct_" + itoa(level) + "_" + itoa((dt.cols / sizeof(detection_t))) + ".png",
-        result);
-    cv::imshow("res", result);
-    cv::waitKey(0);
-}
-
-INSTANTIATE_TEST_CASE_P(inLevel, SCSpecific,
-    testing::Combine(
-        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-        testing::Range(0, 47)
-        ));
-
 #endif
\ No newline at end of file

From 838842cc96e1f09cbb97c189a9653c46657ac107 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 3 Oct 2012 16:36:00 +0400
Subject: [PATCH 036/155] Add performance detection test in ROI; refactored
 soft cascade performance tests

---
 modules/gpu/perf/perf_objdetect.cpp | 187 +++++++++++++++++++++++++++-
 1 file changed, 185 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index a86337112..2224194bb 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -89,11 +89,90 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
     SANITY_CHECK(found_locations);
 }
 
+//================================================= ICF SoftCascade =================================================//
+
 typedef pair<string, string> pair_string;
 DEF_PARAM_TEST_1(SoftCascade, pair_string);
 
-PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml",
-                                                              "cv/cascadeandhog/bahnhof/image_00000000_0.png")))
+
+// struct SoftCascadeTest : public perf::TestBaseWithParam<roi_fixture_t>
+// {
+//     typedef cv::gpu::SoftCascade::Detection detection_t;
+//     static cv::Rect getFromTable(int idx)
+//     {
+//         static const cv::Rect rois[] =
+//         {
+//             cv::Rect( 65,  20,  35, 80),
+//             cv::Rect( 95,  35,  45, 40),
+//             cv::Rect( 45,  35,  45, 40),
+//             cv::Rect( 25,  27,  50, 45),
+//             cv::Rect(100,  50,  45, 40),
+
+//             cv::Rect( 60,  30,  45, 40),
+//             cv::Rect( 40,  55,  50, 40),
+//             cv::Rect( 48,  37,  72, 80),
+//             cv::Rect( 48,  32,  85, 58),
+//             cv::Rect( 48,   0,  32, 27)
+//         };
+
+//         return rois[idx];
+//     }
+
+//     static std::string itoa(long i)
+//     {
+//         static char s[65];
+//         sprintf(s, "%ld", i);
+//         return std::string(s);
+//     }
+
+//     static std::string getImageName(int level)
+//     {
+//         time_t rawtime;
+//         struct tm * timeinfo;
+//         char buffer [80];
+
+//         time ( &rawtime );
+//         timeinfo = localtime ( &rawtime );
+
+//         strftime (buffer,80,"%Y-%m-%d--%H-%M-%S",timeinfo);
+//         return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
+//     }
+
+//     static void print(std::ostream &out, const detection_t& d)
+//     {
+//         out << "\x1b[32m[ detection]\x1b[0m ("
+//             << std::setw(4)  << d.x
+//             << " "
+//             << std::setw(4)  << d.y
+//             << ") ("
+//             << std::setw(4)  << d.w
+//             << " "
+//             << std::setw(4)  << d.h
+//             << ") "
+//             << std::setw(12) << d.confidence
+//             <<  std::endl;
+//     }
+
+//     static void printTotal(std::ostream &out, int detbytes)
+//     {
+//         out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(detection_t)) << std::endl;
+//     }
+
+//     static void writeResult(const cv::Mat& result, const int level)
+//     {
+//         std::string path = cv::tempfile(getImageName(level).c_str());
+//         cv::imwrite(path, result);
+//         std::cout << "\x1b[32m" << "[          ]" << std::endl << "[ stored in]"<< "\x1b[0m" << path << std::endl;
+//     }
+// };
+
+typedef std::tr1::tuple<std::string, std::string> fixture_t;
+typedef perf::TestBaseWithParam<fixture_t> SoftCascadeTest;
+
+PERF_TEST_P(SoftCascadeTest, detect,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
 {
     if (runOnGpu)
     {
@@ -133,6 +212,110 @@ PERF_TEST_P(SoftCascade, detect, Values<pair_string>(make_pair("cv/cascadeandhog
     }
 }
 
+static cv::Rect getFromTable(int idx)
+{
+    static const cv::Rect rois[] =
+    {
+        cv::Rect( 65,  20,  35, 80),
+        cv::Rect( 95,  35,  45, 40),
+        cv::Rect( 45,  35,  45, 40),
+        cv::Rect( 25,  27,  50, 45),
+        cv::Rect(100,  50,  45, 40),
+
+        cv::Rect( 60,  30,  45, 40),
+        cv::Rect( 40,  55,  50, 40),
+        cv::Rect( 48,  37,  72, 80),
+        cv::Rect( 48,  32,  85, 58),
+        cv::Rect( 48,   0,  32, 27)
+    };
+
+    return rois[idx];
+}
+
+typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
+typedef perf::TestBaseWithParam<roi_fixture_t> SoftCascadeTestRoi;
+
+PERF_TEST_P(SoftCascadeTestRoi, detectInRoi,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 5)))
+{
+    if (runOnGpu)
+    {
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
+
+        cv::gpu::SoftCascade cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+        rois.setTo(0);
+
+        int nroi = GET_PARAM(2);
+        cv::RNG rng;
+        for (int i = 0; i < nroi; ++i)
+        {
+            cv::Rect r = getFromTable(rng(10));
+            cv::gpu::GpuMat sub(rois, r);
+            sub.setTo(1);
+        }
+
+        cv::gpu::GpuMat curr = objectBoxes;
+        cascade.detectMultiScale(colored, rois, curr);
+
+        TEST_CYCLE()
+        {
+            curr = objectBoxes;
+            cascade.detectMultiScale(colored, rois, curr);
+        }
+    }
+    else
+    {
+        FAIL();
+    }
+}
+
+PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 10)))
+{
+    if (runOnGpu)
+    {
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
+
+        cv::gpu::SoftCascade cascade;
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+        rois.setTo(0);
+
+        int idx = GET_PARAM(2);
+        cv::Rect r = getFromTable(idx);
+        cv::gpu::GpuMat sub(rois, r);
+        sub.setTo(1);
+
+        cv::gpu::GpuMat curr = objectBoxes;
+        cascade.detectMultiScale(colored, rois, curr);
+
+        TEST_CYCLE()
+        {
+            curr = objectBoxes;
+            cascade.detectMultiScale(colored, rois, curr);
+        }
+    }
+    else
+    {
+        FAIL();
+    }
+}
+
+
 ///////////////////////////////////////////////////////////////
 // HaarClassifier
 

From fdef0adf95052f79a600f77cfb54e41383fa2e58 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 3 Oct 2012 16:39:37 +0400
Subject: [PATCH 037/155] Corrects objects matrix in case of the absence of
 objects

---
 modules/gpu/src/softcascade.cpp | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 9ea365c5e..8b73ae639 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -422,19 +422,15 @@ inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<device::ic
         if (::fabs(scale - maxScale) < FLT_EPSILON) break;
         scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
 
-        // printf("level: %d (%f %f) [%f %f] (%d %d) (%d %d)\n", level.octave, level.relScale, level.shrScale,
-        //     level.scaling[0], level.scaling[1], level.workRect.x, level.workRect.y, level.objSize.x,
-        //level.objSize.y);
-
-        std::cout << "level " << sc
-                  << " octeve "
-                  << vlevels[sc].octave
-                  << " relScale "
-                  << vlevels[sc].relScale
-                  << " " << vlevels[sc].shrScale
-                  << " [" << (int)vlevels[sc].objSize.x
-                  << " " <<  (int)vlevels[sc].objSize.y << "] ["
-        <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
+        // std::cout << "level " << sc
+        //           << " octeve "
+        //           << vlevels[sc].octave
+        //           << " relScale "
+        //           << vlevels[sc].relScale
+        //           << " " << vlevels[sc].shrScale
+        //           << " [" << (int)vlevels[sc].objSize.x
+        //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
+        // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
     }
 
     levels.upload(cv::Mat(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
@@ -578,7 +574,10 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     cv::Mat out(flds.detCounter);
     int ndetections = *(out.data);
 
-    objects = GpuMat(objects, cv::Rect(0, 0, ndetections * sizeof(Detection), 1));
+    if (! ndetections)
+        objects = GpuMat();
+    else
+        objects = GpuMat(objects, cv::Rect(0, 0, ndetections * sizeof(Detection), 1));
 }
 
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream) const

From 30bce16ad6a79e1b2e1f9f78e524a9faddb63b1f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 8 Oct 2012 15:37:28 +0400
Subject: [PATCH 038/155] optimize roi loads

only one thread load roi for all block
---
 modules/gpu/perf/perf_objdetect.cpp   | 42 ++++++++++--------
 modules/gpu/src/cuda/isf-sc.cu        | 62 +++++++++------------------
 modules/gpu/src/softcascade.cpp       |  2 +-
 modules/gpu/test/test_softcascade.cpp | 22 +++++++---
 4 files changed, 62 insertions(+), 66 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 2224194bb..e6efcc2d6 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -176,33 +176,35 @@ PERF_TEST_P(SoftCascadeTest, detect,
 {
     if (runOnGpu)
     {
-        cv::Mat cpu = readImage (GetParam().second);
+        cv::Mat cpu = readImage (GET_PARAM(1));
         ASSERT_FALSE(cpu.empty());
         cv::gpu::GpuMat colored(cpu);
 
         cv::gpu::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GetParam().first)));
+        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
 
-        cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
-
-        rois.setTo(0);
-        cv::gpu::GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-        sub.setTo(cv::Scalar::all(1));
-        cascade.detectMultiScale(colored, rois, objectBoxes);
+        cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+        rois.setTo(1);
+        cv::gpu::transpose(rois, trois);
+        cascade.detectMultiScale(colored, trois, objectBoxes);
 
         TEST_CYCLE()
         {
-            cascade.detectMultiScale(colored, rois, objectBoxes);
+            cascade.detectMultiScale(colored, trois, objectBoxes);
         }
-    } else
+    }
+    else
     {
-        cv::Mat colored = readImage(GetParam().second);
+        cv::Mat colored = readImage(GET_PARAM(1));
         ASSERT_FALSE(colored.empty());
 
         cv::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(getDataPath(GetParam().first)));
+        ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
 
-        std::vector<cv::Rect> rois, objectBoxes;
+        std::vector<cv::Rect> rois;
+
+        typedef cv::SoftCascade::Detection Detection;
+        std::vector<Detection>objectBoxes;
         cascade.detectMultiScale(colored, rois, objectBoxes);
 
         TEST_CYCLE()
@@ -262,13 +264,16 @@ PERF_TEST_P(SoftCascadeTestRoi, detectInRoi,
             sub.setTo(1);
         }
 
+        cv::gpu::GpuMat trois;
+        cv::gpu::transpose(rois, trois);
+
         cv::gpu::GpuMat curr = objectBoxes;
-        cascade.detectMultiScale(colored, rois, curr);
+        cascade.detectMultiScale(colored, trois, curr);
 
         TEST_CYCLE()
         {
             curr = objectBoxes;
-            cascade.detectMultiScale(colored, rois, curr);
+            cascade.detectMultiScale(colored, trois, curr);
         }
     }
     else
@@ -301,7 +306,10 @@ PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
         sub.setTo(1);
 
         cv::gpu::GpuMat curr = objectBoxes;
-        cascade.detectMultiScale(colored, rois, curr);
+        cv::gpu::GpuMat trois;
+        cv::gpu::transpose(rois, trois);
+
+        cascade.detectMultiScale(colored, trois, curr);
 
         TEST_CYCLE()
         {
@@ -372,7 +380,7 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    if (PERF_RUN_GPU())
+    if (runOnGpu)
     {
         cv::gpu::CascadeClassifier_GPU d_cascade;
         ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 4bde7f7ea..8df6907df 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -86,7 +86,6 @@ namespace icf {
     }
 
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
-    texture<char,  cudaTextureType2D, cudaReadModeElementType> troi;
 
     template<bool isUp>
     __device__ __forceinline__ float rescale(const Level& level, Node& node)
@@ -130,11 +129,6 @@ namespace icf {
         float relScale = level.relScale;
         float farea = scaledRect.z * scaledRect.w;
 
-        dprintf("%d: feature %d box %d %d %d %d\n",threadIdx.x, (node.threshold >> 28), scaledRect.x, scaledRect.y,
-            scaledRect.z, scaledRect.w);
-        dprintf("%d: rescale: %f [%f %f] selected %f\n",threadIdx.x, level.relScale, level.scaling[0], level.scaling[1],
-            level.scaling[(node.threshold >> 28) > 6]);
-
         // rescale
         scaledRect.x = __float2int_rn(relScale * scaledRect.x);
         scaledRect.y = __float2int_rn(relScale * scaledRect.y);
@@ -146,15 +140,7 @@ namespace icf {
         const float expected_new_area = farea * relScale * relScale;
         float approx = __fdividef(sarea, expected_new_area);
 
-        dprintf("%d: new rect: %d box %d %d %d %d  rel areas %f %f\n",threadIdx.x, (node.threshold >> 28),
-        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
-
-        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
-
-        rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
-
-        dprintf("%d: approximation %f %d -> %f %f\n",threadIdx.x, approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
-            level.scaling[(node.threshold >> 28) > 6]);
+        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx * level.scaling[(node.threshold >> 28) > 6];
 
         return rootThreshold;
     }
@@ -162,33 +148,17 @@ namespace icf {
     template<bool isUp>
     __device__ __forceinline__ int get(int x, int y, uchar4 area)
     {
-
-        dprintf("%d: feature box %d %d %d %d\n",threadIdx.x, area.x, area.y, area.z, area.w);
-        dprintf("%d: extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",threadIdx.x,
-            x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
-            x + area.x, y + area.w);
-        dprintf("%d: at point %d %d with offset %d\n", x, y, 0);
-
         int a = tex2D(thogluv, x + area.x, y + area.y);
         int b = tex2D(thogluv, x + area.z, y + area.y);
         int c = tex2D(thogluv, x + area.z, y + area.w);
         int d = tex2D(thogluv, x + area.x, y + area.w);
 
-        dprintf("%d   retruved integral values: %d %d %d %d\n",threadIdx.x, a, b, c, d);
-
         return (a - b + c - d);
     }
 
     template<>
     __device__ __forceinline__ int get<true>(int x, int y, uchar4 area)
     {
-
-        dprintf("%d: feature box %d %d %d %d\n",threadIdx.x, area.x, area.y, area.z, area.w);
-        dprintf("%d: extract feature for: [%d %d] [%d %d] [%d %d] [%d %d]\n",threadIdx.x,
-            x + area.x, y + area.y,  x + area.z, y + area.y,  x + area.z,y + area.w,
-            x + area.x, y + area.w);
-        dprintf("%d: at point %d %d with offset %d\n", x, y, 0);
-
         x += area.x;
         y += area.y;
         int a = tex2D(thogluv, x, y);
@@ -196,11 +166,10 @@ namespace icf {
         int c = tex2D(thogluv, x + area.z, y + area.w);
         int d = tex2D(thogluv, x, y + area.w);
 
-        dprintf("%d   retruved integral values: %d %d %d %d\n",threadIdx.x, a, b, c, d);
-
         return (a - b + c - d);
     }
 
+    texture<float2,  cudaTextureType2D, cudaReadModeElementType> troi;
 #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
     template<bool isUp>
     __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
@@ -210,12 +179,21 @@ namespace icf {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x;
 
+        __shared__ volatile char roiCache[8];
+
+        if (!threadIdx.y && !threadIdx.x)
+        {
+            ((float2*)roiCache)[threadIdx.x] = tex2D(troi, blockIdx.y, x);
+        }
+
+        __syncthreads();
+
+        if (!roiCache[threadIdx.y]) return;
+
         Level level = levels[downscales + blockIdx.z];
 
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
-        if (!tex2D(troi, x, y)) return;
-
         Octave octave = octaves[level.octave];
         int st = octave.index * octave.stages;
         const int stEnd = st + 1024;
@@ -282,9 +260,9 @@ namespace icf {
         // if (blockIdx.z != 31) return;
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
-        int roi = tex2D(troi, x, y);
-        printf("%d\n", roi);
-        if (!roi) return;
+        // int roi = tex2D(troi, x, y);
+        // printf("%d\n", roi);
+        // if (!roi) return;
 
         Octave octave = octaves[level.octave];
 
@@ -357,8 +335,8 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<char>();
-        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols, roi.rows, roi.step));
+        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
+        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
 
         test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
         cudaSafeCall( cudaGetLastError());
@@ -391,8 +369,8 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
         cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<char>();
-        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols, roi.rows, roi.step));
+        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
+        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
 
         if (scale >= downscales)
             test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 8b73ae639..e7fcfff27 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -481,7 +481,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     CV_Assert(colored.type() == CV_8UC3);
 
     // we guess user knows about shrincage
-    CV_Assert((rois.size() == getRoiSize()) && (rois.type() == CV_8UC1));
+    CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
 
     // only this window size allowed
     CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 0b266f827..04fa9b181 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -47,7 +47,7 @@
 using cv::gpu::GpuMat;
 
 // show detection results on input image with cv::imshow
-//#define SHOW_DETECTIONS
+#define SHOW_DETECTIONS
 
 #if defined SHOW_DETECTIONS
 # define SHOW(res)           \
@@ -154,26 +154,30 @@ GPU_TEST_P(SoftCascadeTest, detectInROI,
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(cvtest::TS::ptr()->get_data_path() + GET_PARAM(0)));
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
     rois.setTo(0);
 
     int nroi = GET_PARAM(2);
+    cv::Mat result(coloredCpu);
     cv::RNG rng;
     for (int i = 0; i < nroi; ++i)
     {
         cv::Rect r = getFromTable(rng(10));
         GpuMat sub(rois, r);
         sub.setTo(1);
+        r.x *= 4; r.y *= 4; r.width *= 4; r.height *= 4;
+        cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
     }
 
-    cascade.detectMultiScale(colored, rois, objectBoxes);
+    cv::gpu::transpose(rois, trois);
+
+    cascade.detectMultiScale(colored, trois, objectBoxes);
 
     ///
     cv::Mat dt(objectBoxes);
     typedef cv::gpu::SoftCascade::Detection detection_t;
 
     detection_t* dts = (detection_t*)dt.data;
-    cv::Mat result(coloredCpu);
 
     printTotal(std::cout, dt.cols);
     for (int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
@@ -204,8 +208,11 @@ GPU_TEST_P(SoftCascadeTest, detectInLevel,
     GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(detection_t), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
     rois.setTo(1);
 
+    cv::gpu::GpuMat trois;
+    cv::gpu::transpose(rois, trois);
+
     int level = GET_PARAM(2);
-    cascade.detectMultiScale(colored, rois, objectBoxes, 1, level);
+    cascade.detectMultiScale(colored, trois, objectBoxes, 1, level);
 
     cv::Mat dt(objectBoxes);
 
@@ -246,6 +253,9 @@ TEST(SoftCascadeTest, detect)
     GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
     sub.setTo(cv::Scalar::all(1));
 
-    cascade.detectMultiScale(colored, rois, objectBoxes);
+    cv::gpu::GpuMat trois;
+    cv::gpu::transpose(rois, trois);
+
+    cascade.detectMultiScale(colored, trois, objectBoxes);
 }
 #endif
\ No newline at end of file

From 1b9bccb856c7ff2f80c99b6b085db264cffcf79d Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 8 Oct 2012 20:20:57 +0400
Subject: [PATCH 039/155] move Level into shared memory

---
 modules/gpu/src/cuda/isf-sc.cu | 24 +++++++-----------------
 modules/gpu/src/icf.hpp        |  2 ++
 2 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 8df6907df..f755f8549 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -94,11 +94,6 @@ namespace icf {
         float relScale = level.relScale;
         float farea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
-        dprintf("%d: feature %d box %d %d %d %d\n",threadIdx.x, (node.threshold >> 28), scaledRect.x, scaledRect.y,
-            scaledRect.z, scaledRect.w);
-        dprintf("%d: rescale: %f [%f %f] selected %f\n",threadIdx.x, level.relScale, level.scaling[0], level.scaling[1],
-            level.scaling[(node.threshold >> 28) > 6]);
-
         // rescale
         scaledRect.x = __float2int_rn(relScale * scaledRect.x);
         scaledRect.y = __float2int_rn(relScale * scaledRect.y);
@@ -110,14 +105,7 @@ namespace icf {
         const float expected_new_area = farea * relScale * relScale;
         float approx = __fdividef(sarea, expected_new_area);
 
-        dprintf("%d: new rect: %d box %d %d %d %d  rel areas %f %f\n",threadIdx.x, (node.threshold >> 28),
-        scaledRect.x, scaledRect.y, scaledRect.z, scaledRect.w, farea * relScale * relScale, sarea);
-
-        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx;
-        rootThreshold *= level.scaling[(node.threshold >> 28) > 6];
-
-        dprintf("%d: approximation %f %d -> %f %f\n",threadIdx.x, approx, (node.threshold & 0x0FFFFFFFU), rootThreshold,
-            level.scaling[(node.threshold >> 28) > 6]);
+        float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx * level.scaling[(node.threshold >> 28) > 6];
 
         return rootThreshold;
     }
@@ -179,18 +167,20 @@ namespace icf {
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
         const int x = blockIdx.x;
 
-        __shared__ volatile char roiCache[8];
+        // load Lavel
+        __shared__ Level level;
 
+        // check POI
+        __shared__ volatile char roiCache[8];
         if (!threadIdx.y && !threadIdx.x)
-        {
             ((float2*)roiCache)[threadIdx.x] = tex2D(troi, blockIdx.y, x);
-        }
 
         __syncthreads();
 
         if (!roiCache[threadIdx.y]) return;
 
-        Level level = levels[downscales + blockIdx.z];
+        if (!threadIdx.x)
+            level = levels[downscales + blockIdx.z];
 
         if(x >= level.workRect.x || y >= level.workRect.y) return;
 
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 35658892f..a103341fb 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -90,6 +90,8 @@ struct __align__(8) Level //is actually 24 bytes
         objSize.x  = round(oct.size.x * relScale);
         objSize.y  = round(oct.size.y * relScale);
     }
+
+    __device Level(){}
 };
 
 struct __align__(8) Node

From 0424e2c8d2da9aefa9b8b6898216e7361e3141c3 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 14:19:24 +0400
Subject: [PATCH 040/155] remove debug code

---
 modules/gpu/src/softcascade.cpp | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index e7fcfff27..b834e0319 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -463,15 +463,6 @@ bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, c
     return true;
 }
 
-#define USE_REFERENCE_VALUES
-namespace {
-    char *itoa(long i, char* s, int /*dummy_radix*/)
-    {
-        sprintf(s, "%ld", i);
-        return s;
-    }
-}
-
 //================================== synchronous version ============================================================//
 
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& rois,
@@ -488,22 +479,6 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 
     Filds& flds = *filds;
 
-#if defined USE_REFERENCE_VALUES
-    cudaMemset(flds.hogluv.data, 0, flds.hogluv.step * flds.hogluv.rows);
-
-    cv::FileStorage imgs("/home/kellan/testInts.xml", cv::FileStorage::READ);
-    char buff[33];
-
-    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-    {
-        cv::Mat channel;
-        imgs[std::string("channel") + itoa(i, buff, 10)] >> channel;
-
-        // std::cout << "channel " << i << std::endl << channel << std::endl;
-        GpuMat gchannel(flds.hogluv, cv::Rect(0, 121 * i, 161, 121));
-        gchannel.upload(channel);
-    }
-#else
     GpuMat& plane = flds.plane;
     GpuMat& shrunk = flds.shrunk;
     cudaMemset(plane.data, 0, plane.step * plane.rows);
@@ -512,8 +487,6 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     int fh = Filds::FRAME_HEIGHT;
 
     GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
-
-    //cv::gpu::cvtColor(colored, gray, CV_RGB2GRAY);
     cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
 
     //create hog
@@ -564,7 +537,6 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
         GpuMat sum(flds.hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
         cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
     }
-#endif
 
     if (specificScale == -1)
         flds.detect(rois,objects, 0);

From ef431f70b640acb969a90b44ed5ffef5a2774719 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 16:26:32 +0400
Subject: [PATCH 041/155] fix buggy threshold zeroing if feature has zero area

---
 modules/gpu/src/cuda/isf-sc.cu | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index f755f8549..f74673c05 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -103,7 +103,7 @@ namespace icf {
         float sarea = (scaledRect.z - scaledRect.x) * (scaledRect.w - scaledRect.y);
 
         const float expected_new_area = farea * relScale * relScale;
-        float approx = __fdividef(sarea, expected_new_area);
+        float approx = (sarea == 0)? 1: __fdividef(sarea, expected_new_area);
 
         float rootThreshold = (node.threshold & 0x0FFFFFFFU) * approx * level.scaling[(node.threshold >> 28) > 6];
 
@@ -226,7 +226,7 @@ namespace icf {
             dprintf("%d: impact scaned %f\n" ,threadIdx.x, impact);
 
             confidence += impact;
-            if(__any((confidence <= stages[(st + threadIdx.x)]))) st += stEnd;
+            if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
         }
 
         if(st == stEnd && !threadIdx.x)

From 312a58fcec5d8478cf95352e990ab24601c0108a Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 16:27:23 +0400
Subject: [PATCH 042/155] fix performance test

---
 modules/gpu/perf/perf_objdetect.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index e6efcc2d6..ced8ee17d 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -186,11 +186,14 @@ PERF_TEST_P(SoftCascadeTest, detect,
         cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
         rois.setTo(1);
         cv::gpu::transpose(rois, trois);
-        cascade.detectMultiScale(colored, trois, objectBoxes);
+
+        cv::gpu::GpuMat curr = objectBoxes;
+        cascade.detectMultiScale(colored, trois, curr);
 
         TEST_CYCLE()
         {
-            cascade.detectMultiScale(colored, trois, objectBoxes);
+            curr = objectBoxes;
+            cascade.detectMultiScale(colored, trois, curr);
         }
     }
     else

From fa62e2b72f5d1d84b1d056d0e42b80486e210f71 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 16:47:49 +0400
Subject: [PATCH 043/155] move preprocessing into separate function

---
 modules/gpu/src/softcascade.cpp | 134 +++++++++++++++++---------------
 1 file changed, 72 insertions(+), 62 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index b834e0319..8fa82867f 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -93,6 +93,10 @@ namespace icf {
                        PtrStepSzi counter,
                        const int downscales);
 }
+namespace imgproc
+{
+    void meanShiftFiltering_gpu(const PtrStepSzb& src, PtrStepSzb dst, int sp, int sr, int maxIter, float eps, cudaStream_t stream);
+}
 }}}
 
 struct cv::gpu::SoftCascade::Filds
@@ -104,8 +108,8 @@ struct cv::gpu::SoftCascade::Filds
         fplane.create(FRAME_HEIGHT * 6, FRAME_WIDTH, CV_32FC1);
         luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
         shrunk.create(FRAME_HEIGHT / 4 * HOG_LUV_BINS, FRAME_WIDTH / 4, CV_8UC1);
-        integralBuffer.create(shrunk.rows + 1 * HOG_LUV_BINS, shrunk.cols + 1, CV_32SC1);
-        hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 1, CV_32SC1);
+        integralBuffer.create(1 , (shrunk.rows + 1) * HOG_LUV_BINS * (shrunk.cols + 1), CV_32SC1);
+        hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 64, CV_32SC1);
         detCounter.create(1,1, CV_32SC1);
     }
 
@@ -146,6 +150,8 @@ struct cv::gpu::SoftCascade::Filds
 
     std::vector<float> scales;
 
+    static const int shrinkage = 4;
+
     enum { BOOST = 0 };
     enum
     {
@@ -160,19 +166,80 @@ struct cv::gpu::SoftCascade::Filds
     };
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(cv::gpu::GpuMat roi, cv::gpu::GpuMat objects, cudaStream_t stream) const
+    void detect(const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
         device::icf::detect(roi, levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter, downscales);
     }
 
-    void detectAtScale(int scale, cv::gpu::GpuMat roi, cv::gpu::GpuMat objects, cudaStream_t stream) const
+    void detectAtScale(int scale, const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
         device::icf::detectAtScale(scale, roi, levels, octaves, stages, nodes, leaves, hogluv, objects,
             detCounter, downscales);
     }
 
+    void preprocess(const cv::gpu::GpuMat& colored)
+    {
+        cudaMemset(plane.data, 0, plane.step * plane.rows);
+
+        int fw = Filds::FRAME_WIDTH;
+        int fh = Filds::FRAME_HEIGHT;
+
+        GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
+        cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
+
+        //create hog
+        GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
+        GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
+
+        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
+        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
+
+        GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
+        GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
+
+        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
+
+        // normolize magnitude to uchar interval and angles to 6 bins
+
+        GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
+        GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
+
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
+        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
+
+        //create uchar magnitude
+        GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
+        nmag.convertTo(cmag, CV_8UC1);
+
+        // create luv
+        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv);
+
+        std::vector<GpuMat> splited;
+        for(int i = 0; i < Filds::LUV_BINS; ++i)
+        {
+            splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
+        }
+
+        cv::gpu::split(luv, splited);
+
+        device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
+
+        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
+        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+
+        fw /= shrinkage;
+        fh /= shrinkage;
+
+        for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+        {
+            GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
+            GpuMat sum(hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
+            cv::gpu::integralBuffered(channel, sum, integralBuffer);
+        }
+    }
+
 private:
     void calcLevels(const std::vector<device::icf::Octave>& octs,
                                                     int frameW, int frameH, int nscales);
@@ -479,64 +546,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 
     Filds& flds = *filds;
 
-    GpuMat& plane = flds.plane;
-    GpuMat& shrunk = flds.shrunk;
-    cudaMemset(plane.data, 0, plane.step * plane.rows);
-
-    int fw = Filds::FRAME_WIDTH;
-    int fh = Filds::FRAME_HEIGHT;
-
-    GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
-    cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
-
-    //create hog
-    GpuMat dfdx(flds.fplane, cv::Rect(0,  0, fw, fh));
-    GpuMat dfdy(flds.fplane, cv::Rect(0, fh, fw, fh));
-
-    cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
-    cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
-
-    GpuMat mag(flds.fplane, cv::Rect(0, 2 * fh, fw, fh));
-    GpuMat ang(flds.fplane, cv::Rect(0, 3 * fh, fw, fh));
-
-    cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
-
-    // normolize magnitude to uchar interval and angles to 6 bins
-
-    GpuMat nmag(flds.fplane, cv::Rect(0, 4 * fh, fw, fh));
-    GpuMat nang(flds.fplane, cv::Rect(0, 5 * fh, fw, fh));
-
-    cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
-    cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
-
-    //create uchar magnitude
-    GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
-    nmag.convertTo(cmag, CV_8UC1);
-
-    // create luv
-    cv::gpu::cvtColor(colored, flds.luv, CV_BGR2Luv);
-
-    std::vector<GpuMat> splited;
-    for(int i = 0; i < Filds::LUV_BINS; ++i)
-    {
-        splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
-    }
-
-    cv::gpu::split(flds.luv, splited);
-
-    device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
-
-    GpuMat hogluv(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
-    cv::gpu::resize(hogluv, flds.shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-
-    fw /= 4;
-    fh /= 4;
-    for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-    {
-        GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
-        GpuMat sum(flds.hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
-        cv::gpu::integralBuffered(channel, sum, flds.integralBuffer);
-    }
+    flds.preprocess(colored);
 
     if (specificScale == -1)
         flds.detect(rois,objects, 0);

From 916ba4c0ea1493c6883e45d990a85421f975a60b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 17:05:23 +0400
Subject: [PATCH 044/155] refactor preprocessing

---
 modules/gpu/src/softcascade.cpp | 122 +++++++++++++++++++-------------
 1 file changed, 71 insertions(+), 51 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 8fa82867f..c93949f1c 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -183,61 +183,16 @@ struct cv::gpu::SoftCascade::Filds
     {
         cudaMemset(plane.data, 0, plane.step * plane.rows);
 
-        int fw = Filds::FRAME_WIDTH;
-        int fh = Filds::FRAME_HEIGHT;
+        static const int fw = Filds::FRAME_WIDTH;
+        static const int fh = Filds::FRAME_HEIGHT;
 
         GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
         cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
+        createHogBins(gray);
 
-        //create hog
-        GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
-        GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
+        createLuvBins(colored);
 
-        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
-        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
-
-        GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
-        GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
-
-        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
-
-        // normolize magnitude to uchar interval and angles to 6 bins
-
-        GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
-        GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
-
-        cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
-        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
-
-        //create uchar magnitude
-        GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
-        nmag.convertTo(cmag, CV_8UC1);
-
-        // create luv
-        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv);
-
-        std::vector<GpuMat> splited;
-        for(int i = 0; i < Filds::LUV_BINS; ++i)
-        {
-            splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
-        }
-
-        cv::gpu::split(luv, splited);
-
-        device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
-
-        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
-        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-
-        fw /= shrinkage;
-        fh /= shrinkage;
-
-        for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-        {
-            GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
-            GpuMat sum(hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
-            cv::gpu::integralBuffered(channel, sum, integralBuffer);
-        }
+        integrate();
     }
 
 private:
@@ -263,6 +218,72 @@ private:
         }
         return res;
     }
+
+    void createHogBins(const cv::gpu::GpuMat& gray)
+    {
+        static const int fw = Filds::FRAME_WIDTH;
+        static const int fh = Filds::FRAME_HEIGHT;
+
+        GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
+        GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
+
+        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
+        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
+
+        GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
+        GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
+
+        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
+
+        // normolize magnitude to uchar interval and angles to 6 bins
+
+        GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
+        GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
+
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
+        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
+
+        //create uchar magnitude
+        GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
+        nmag.convertTo(cmag, CV_8UC1);
+
+        device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
+    }
+
+    void createLuvBins(const cv::gpu::GpuMat& colored)
+    {
+        static const int fw = Filds::FRAME_WIDTH;
+        static const int fh = Filds::FRAME_HEIGHT;
+
+        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv);
+
+        std::vector<GpuMat> splited;
+        for(int i = 0; i < Filds::LUV_BINS; ++i)
+        {
+            splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
+        }
+
+        cv::gpu::split(luv, splited);
+    }
+
+    void integrate()
+    {
+        int fw = Filds::FRAME_WIDTH;
+        int fh = Filds::FRAME_HEIGHT;
+
+        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
+        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+
+        fw /= shrinkage;
+        fh /= shrinkage;
+
+        for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
+        {
+            GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
+            GpuMat sum(hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
+            cv::gpu::integralBuffered(channel, sum, integralBuffer);
+        }
+    }
 };
 
 bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
@@ -572,5 +593,4 @@ cv::Size cv::gpu::SoftCascade::getRoiSize() const
     return cv::Size(Filds::FRAME_WIDTH / 4, Filds::FRAME_HEIGHT / 4);
 }
 
-
 #endif
\ No newline at end of file

From 0898c3c651ef6196a2287d61ef9d6644b5653743 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 18:24:48 +0400
Subject: [PATCH 045/155] kernel policy

---
 modules/gpu/src/cuda/isf-sc.cu  | 62 +++++++++------------------------
 modules/gpu/src/icf.hpp         | 27 ++++++++++++++
 modules/gpu/src/softcascade.cpp | 44 +++++------------------
 3 files changed, 52 insertions(+), 81 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index f74673c05..74e47ba19 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -303,21 +303,16 @@ namespace icf {
     }
 #endif
 
-    void detect(const PtrStepSzb& roi, const PtrStepSzb& levels, const PtrStepSzb& octaves, const PtrStepSzf& stages,
-                const PtrStepSzb& nodes,  const PtrStepSzf& leaves,  const PtrStepSzi& hogluv,
-                PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales)
+    template<>
+    void CascadeInvoker<CascadePolicy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
+        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale) const
     {
         int fw = 160;
         int fh = 120;
 
         dim3 block(32, 8);
-        dim3 grid(fw, fh / 8, downscales);
+        dim3 grid(fw, fh / 8, (scale == -1) ? downscales : 1);
 
-        const Level* l = (const Level*)levels.ptr();
-        const Octave* oct = ((const Octave*)octaves.ptr());
-        const float* st = (const float*)stages.ptr();
-        const Node* nd = (const Node*)nodes.ptr();
-        const float* lf = (const float*)leaves.ptr();
         uint* ctr = (uint*)counter.ptr();
         Detection* det = (Detection*)objects.ptr();
         uint max_det = objects.cols / sizeof(Detection);
@@ -328,44 +323,21 @@ namespace icf {
         cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
         cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
 
-        test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, 0);
-        cudaSafeCall( cudaGetLastError());
+        if (scale == -1)
+        {
+            test_kernel_warp<false><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, 0);
+            cudaSafeCall( cudaGetLastError());
 
-        grid = dim3(fw, fh / 8, 47 - downscales);
-        test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, downscales);
-        cudaSafeCall( cudaGetLastError());
-        cudaSafeCall( cudaDeviceSynchronize());
-    }
-
-    void detectAtScale(const int scale, const PtrStepSzb& roi, const PtrStepSzb& levels, const PtrStepSzb& octaves,
-        const PtrStepSzf& stages, const PtrStepSzb& nodes, const PtrStepSzf& leaves, const PtrStepSzi& hogluv,
-        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales)
-    {
-        int fw = 160;
-        int fh = 120;
-
-        dim3 block(32, 8);
-        dim3 grid(fw, fh / 8, 1);
-
-        const Level* l = (const Level*)levels.ptr();
-        const Octave* oct = ((const Octave*)octaves.ptr());
-        const float* st = (const float*)stages.ptr();
-        const Node* nd = (const Node*)nodes.ptr();
-        const float* lf = (const float*)leaves.ptr();
-        uint* ctr = (uint*)counter.ptr();
-        Detection* det = (Detection*)objects.ptr();
-        uint max_det = objects.cols / sizeof(Detection);
-
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
-        cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
-
-        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
-        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
-
-        if (scale >= downscales)
-            test_kernel_warp<true><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
+            grid = dim3(fw, fh / 8, 47 - downscales);
+            test_kernel_warp<true><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, downscales);
+        }
         else
-            test_kernel_warp<false><<<grid, block>>>(l, oct, st, nd, lf, det, max_det, ctr, scale);
+        {
+            if (scale >= downscales)
+                test_kernel_warp<true><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
+            else
+                test_kernel_warp<false><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
+        }
 
         cudaSafeCall( cudaGetLastError());
         cudaSafeCall( cudaDeviceSynchronize());
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index a103341fb..06c81149e 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -124,6 +124,33 @@ struct __align__(16) Detection
     : x(_x), y(_y), w(_w), h(_h), confidence(c), kind(0) {};
 };
 
+struct CascadePolicy
+{
+    enum {STA_X = 32, STA_Y = 8};
+};
+
+template<typename Policy>
+struct CascadeInvoker
+{
+    CascadeInvoker(): levels(0), octaves(0), stages(0), nodes(0), leaves(0) {}
+    CascadeInvoker(const PtrStepSzb& _levels, const PtrStepSzb& _octaves, const PtrStepSzf& _stages,
+                   const PtrStepSzb& _nodes,  const PtrStepSzf& _leaves)
+    : levels((const Level*)_levels.ptr()), octaves((const Octave*)_octaves.ptr()), stages((const float*)_stages.ptr()),
+       nodes((const Node*)_nodes.ptr()), leaves((const float*)_leaves.ptr())
+    {}
+
+    const Level*  levels;
+    const Octave* octaves;
+
+    const float*  stages;
+
+    const Node*   nodes;
+    const float*  leaves;
+
+    void operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
+        PtrStepSzi counter, const int downscales, const int csale = -1) const;
+};
+
 }
 }}}
 
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index c93949f1c..f25c5a34d 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -69,29 +69,6 @@ namespace cv { namespace gpu { namespace device {
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
-
-    void detect(const PtrStepSzb& rois,
-                const PtrStepSzb& levels,
-                const PtrStepSzb& octaves,
-                const PtrStepSzf& stages,
-                const PtrStepSzb& nodes,
-                const PtrStepSzf& leaves,
-                const PtrStepSzi& hogluv,
-                PtrStepSz<uchar4> objects,
-                PtrStepSzi counter,
-                const int downscales);
-
-    void detectAtScale(const int scale,
-                       const PtrStepSzb& rois,
-                       const PtrStepSzb& levels,
-                       const PtrStepSzb& octaves,
-                       const PtrStepSzf& stages,
-                       const PtrStepSzb& nodes,
-                       const PtrStepSzf& leaves,
-                       const PtrStepSzi& hogluv,
-                       PtrStepSz<uchar4> objects,
-                       PtrStepSzi counter,
-                       const int downscales);
 }
 namespace imgproc
 {
@@ -150,6 +127,8 @@ struct cv::gpu::SoftCascade::Filds
 
     std::vector<float> scales;
 
+    device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker;
+
     static const int shrinkage = 4;
 
     enum { BOOST = 0 };
@@ -166,17 +145,11 @@ struct cv::gpu::SoftCascade::Filds
     };
 
     bool fill(const FileNode &root, const float mins, const float maxs);
-    void detect(const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
+    void detect(int scale, const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        device::icf::detect(roi, levels, octaves, stages, nodes, leaves, hogluv, objects , detCounter, downscales);
-    }
-
-    void detectAtScale(int scale, const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
-    {
-        cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        device::icf::detectAtScale(scale, roi, levels, octaves, stages, nodes, leaves, hogluv, objects,
-            detCounter, downscales);
+        // device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker(levels, octaves, stages, nodes, leaves);
+        invoker(roi, hogluv, objects, detCounter, downscales, scale);
     }
 
     void preprocess(const cv::gpu::GpuMat& colored)
@@ -439,6 +412,8 @@ bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, c
     calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
     CV_Assert(!levels.empty());
 
+    invoker = device::icf::CascadeInvoker<device::icf::CascadePolicy>(levels, octaves, stages, nodes, leaves);
+
     return true;
 }
 
@@ -569,10 +544,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
 
     flds.preprocess(colored);
 
-    if (specificScale == -1)
-        flds.detect(rois,objects, 0);
-    else
-        flds.detectAtScale(specificScale, rois, objects, 0);
+    flds.detect(specificScale, rois, objects, 0);
 
     cv::Mat out(flds.detCounter);
     int ndetections = *(out.data);

From f196e9fda44d71d0be5081dcb0c3d618cd8f06a7 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 19:11:39 +0400
Subject: [PATCH 046/155] add factory method for Fields structure

---
 modules/gpu/src/softcascade.cpp | 578 ++++++++++++++++----------------
 1 file changed, 281 insertions(+), 297 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index f25c5a34d..fc7114b5f 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -78,77 +78,255 @@ namespace imgproc
 
 struct cv::gpu::SoftCascade::Filds
 {
+    struct CascadeIntrinsics
+    {
+        static const float lambda = 1.099f, a = 0.89f;
 
-    Filds()
+        static float getFor(int channel, float scaling)
+        {
+            CV_Assert(channel < 10);
+
+            if (fabs(scaling - 1.f) < FLT_EPSILON)
+                return 1.f;
+
+            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
+            static const float A[2][2] =
+            {   //channel <= 6, otherwise
+                {        0.89f, 1.f}, // down
+                {        1.00f, 1.f}  // up
+            };
+
+            static const float B[2][2] =
+            {   //channel <= 6,  otherwise
+                { 1.099f / ::log(2), 2.f}, // down
+                {             0.f, 2.f}  // up
+            };
+
+            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
+            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
+
+            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
+            return a * ::pow(scaling, b);
+        }
+    };
+
+    static Filds* parseCascade(const FileNode &root, const float mins, const float maxs)
+    {
+        static const char *const SC_STAGE_TYPE          = "stageType";
+        static const char *const SC_BOOST               = "BOOST";
+
+        static const char *const SC_FEATURE_TYPE        = "featureType";
+        static const char *const SC_ICF                 = "ICF";
+
+        // only Ada Boost supported
+        std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
+        CV_Assert(stageTypeStr == SC_BOOST);
+
+        // only HOG-like integral channel features cupported
+        string featureTypeStr = (string)root[SC_FEATURE_TYPE];
+        CV_Assert(featureTypeStr == SC_ICF);
+
+        static const char *const SC_ORIG_W              = "width";
+        static const char *const SC_ORIG_H              = "height";
+
+        int origWidth = (int)root[SC_ORIG_W];
+        CV_Assert(origWidth  == ORIG_OBJECT_WIDTH);
+
+        int origHeight = (int)root[SC_ORIG_H];
+        CV_Assert(origHeight == ORIG_OBJECT_HEIGHT);
+
+        static const char *const SC_OCTAVES             = "octaves";
+        static const char *const SC_STAGES              = "stages";
+        static const char *const SC_FEATURES            = "features";
+
+        static const char *const SC_WEEK                = "weakClassifiers";
+        static const char *const SC_INTERNAL            = "internalNodes";
+        static const char *const SC_LEAF                = "leafValues";
+
+        static const char *const SC_OCT_SCALE           = "scale";
+        static const char *const SC_OCT_STAGES          = "stageNum";
+        static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
+
+        static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
+
+        static const char * const SC_F_CHANNEL          = "channel";
+        static const char * const SC_F_RECT             = "rect";
+
+
+        FileNode fn = root[SC_OCTAVES];
+            if (fn.empty()) return false;
+
+        using namespace device::icf;
+
+        std::vector<Octave>  voctaves;
+        std::vector<float>   vstages;
+        std::vector<Node>    vnodes;
+        std::vector<float>   vleaves;
+
+        FileNodeIterator it = fn.begin(), it_end = fn.end();
+        int feature_offset = 0;
+        ushort octIndex = 0;
+        ushort shrinkage = 1;
+
+        for (; it != it_end; ++it)
+        {
+            FileNode fns = *it;
+            float scale = (float)fns[SC_OCT_SCALE];
+
+            bool isUPOctave = scale >= 1;
+
+            ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
+            ushort2 size;
+            size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
+            size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
+            shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
+
+            Octave octave(octIndex, nstages, shrinkage, size, scale);
+            CV_Assert(octave.stages > 0);
+            voctaves.push_back(octave);
+
+            FileNode ffs = fns[SC_FEATURES];
+            if (ffs.empty()) return false;
+
+            FileNodeIterator ftrs = ffs.begin();
+
+            fns = fns[SC_STAGES];
+            if (fn.empty()) return false;
+
+            // for each stage (~ decision tree with H = 2)
+            FileNodeIterator st = fns.begin(), st_end = fns.end();
+            for (; st != st_end; ++st )
+            {
+                fns = *st;
+                vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
+
+                fns = fns[SC_WEEK];
+                FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
+                for (; ftr != ft_end; ++ftr)
+                {
+                    fns = (*ftr)[SC_INTERNAL];
+                    FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
+                    for (; inIt != inIt_end;)
+                    {
+                        // int feature = (int)(*(inIt +=2)) + feature_offset;
+                        inIt +=3;
+                        // extract feature, Todo:check it
+                        uint th = saturate_cast<uint>((float)(*(inIt++)));
+                        cv::FileNode ftn = (*ftrs)[SC_F_RECT];
+                        cv::FileNodeIterator r_it = ftn.begin();
+                        uchar4 rect;
+                        rect.x = saturate_cast<uchar>((int)*(r_it++));
+                        rect.y = saturate_cast<uchar>((int)*(r_it++));
+                        rect.z = saturate_cast<uchar>((int)*(r_it++));
+                        rect.w = saturate_cast<uchar>((int)*(r_it++));
+
+                        if (isUPOctave)
+                        {
+                            rect.z -= rect.x;
+                            rect.w -= rect.y;
+                        }
+
+                        uint channel = saturate_cast<uint>((int)(*ftrs)[SC_F_CHANNEL]);
+                        vnodes.push_back(Node(rect, channel, th));
+                        ++ftrs;
+                    }
+
+                    fns = (*ftr)[SC_LEAF];
+                    inIt = fns.begin(), inIt_end = fns.end();
+                    for (; inIt != inIt_end; ++inIt)
+                        vleaves.push_back((float)(*inIt));
+                }
+            }
+
+            feature_offset += octave.stages * 3;
+            ++octIndex;
+        }
+
+        cv::Mat hoctaves(1, voctaves.size() * sizeof(Octave), CV_8UC1, (uchar*)&(voctaves[0]));
+        CV_Assert(!hoctaves.empty());
+
+        cv::Mat hstages(cv::Mat(vstages).reshape(1,1));
+        CV_Assert(!hstages.empty());
+
+        cv::Mat hnodes(1, vnodes.size() * sizeof(Node), CV_8UC1, (uchar*)&(vnodes[0]) );
+        CV_Assert(!hnodes.empty());
+
+        cv::Mat hleaves(cv::Mat(vleaves).reshape(1,1));
+        CV_Assert(!hleaves.empty());
+
+        std::vector<Level> vlevels;
+        float logFactor = (::log(maxs) - ::log(mins)) / (TOTAL_SCALES -1);
+
+        float scale = mins;
+        int downscales = 0;
+        for (int sc = 0; sc < TOTAL_SCALES; ++sc)
+        {
+            int width  = ::std::max(0.0f, FRAME_WIDTH - (origWidth  * scale));
+            int height = ::std::max(0.0f, FRAME_HEIGHT - (origHeight * scale));
+
+            float logScale = ::log(scale);
+            int fit = fitOctave(voctaves, logScale);
+
+            Level level(fit, voctaves[fit], scale, width, height);
+            level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
+            level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
+
+            if (!width || !height)
+                break;
+            else
+            {
+                vlevels.push_back(level);
+                if (voctaves[fit].scale < 1) ++downscales;
+            }
+
+            if (::fabs(scale - maxs) < FLT_EPSILON) break;
+            scale = ::std::min(maxs, ::expf(::log(scale) + logFactor));
+
+            // std::cout << "level " << sc
+            //           << " octeve "
+            //           << vlevels[sc].octave
+            //           << " relScale "
+            //           << vlevels[sc].relScale
+            //           << " " << vlevels[sc].shrScale
+            //           << " [" << (int)vlevels[sc].objSize.x
+            //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
+            // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
+        }
+
+        cv::Mat hlevels(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );
+        CV_Assert(!hlevels.empty());
+
+        Filds* filds = new Filds(mins, maxs, origWidth, origHeight, shrinkage, downscales,
+            hoctaves, hstages, hnodes, hleaves, hlevels);
+
+        return filds;
+    }
+
+    Filds( const float mins, const float maxs, const int ow, const int oh, const int shr, const int ds,
+        cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves, cv::Mat hlevels)
+    : minScale(mins), maxScale(maxs), origObjWidth(ow), origObjHeight(oh), shrinkage(shr), downscales(ds)
     {
         plane.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
         fplane.create(FRAME_HEIGHT * 6, FRAME_WIDTH, CV_32FC1);
         luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
-        shrunk.create(FRAME_HEIGHT / 4 * HOG_LUV_BINS, FRAME_WIDTH / 4, CV_8UC1);
+        shrunk.create(FRAME_HEIGHT / shr * HOG_LUV_BINS, FRAME_WIDTH / shr, CV_8UC1);
         integralBuffer.create(1 , (shrunk.rows + 1) * HOG_LUV_BINS * (shrunk.cols + 1), CV_32SC1);
-        hogluv.create((FRAME_HEIGHT / 4 + 1) * HOG_LUV_BINS, FRAME_WIDTH / 4 + 64, CV_32SC1);
+        hogluv.create((FRAME_HEIGHT / shr + 1) * HOG_LUV_BINS, FRAME_WIDTH / shr + 64, CV_32SC1);
         detCounter.create(1,1, CV_32SC1);
+
+        octaves.upload(hoctaves);
+        stages.upload(hstages);
+        nodes.upload(hnodes);
+        leaves.upload(hleaves);
+        levels.upload(hlevels);
+
+        invoker = device::icf::CascadeInvoker<device::icf::CascadePolicy>(levels, octaves, stages, nodes, leaves);
+
     }
 
-    // scales range
-    float minScale;
-    float maxScale;
-
-    int origObjWidth;
-    int origObjHeight;
-
-    int downscales;
-
-    GpuMat octaves;
-    GpuMat stages;
-    GpuMat nodes;
-    GpuMat leaves;
-    GpuMat levels;
-
-    GpuMat detCounter;
-
-    // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
-    GpuMat plane;
-
-    // preallocated buffer for floating point operations
-    GpuMat fplane;
-
-    // temporial mat for cvtColor
-    GpuMat luv;
-
-    // 160x120x10
-    GpuMat shrunk;
-
-    // temporial mat for integrall
-    GpuMat integralBuffer;
-
-    // 161x121x10
-    GpuMat hogluv;
-
-    std::vector<float> scales;
-
-    device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker;
-
-    static const int shrinkage = 4;
-
-    enum { BOOST = 0 };
-    enum
-    {
-        FRAME_WIDTH        = 640,
-        FRAME_HEIGHT       = 480,
-        TOTAL_SCALES       = 55,
-        ORIG_OBJECT_WIDTH  = 64,
-        ORIG_OBJECT_HEIGHT = 128,
-        HOG_BINS           = 6,
-        LUV_BINS           = 3,
-        HOG_LUV_BINS       = 10
-    };
-
-    bool fill(const FileNode &root, const float mins, const float maxs);
     void detect(int scale, const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
     {
         cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        // device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker(levels, octaves, stages, nodes, leaves);
         invoker(roi, hogluv, objects, detCounter, downscales, scale);
     }
 
@@ -169,11 +347,9 @@ struct cv::gpu::SoftCascade::Filds
     }
 
 private:
-    void calcLevels(const std::vector<device::icf::Octave>& octs,
-                                                    int frameW, int frameH, int nscales);
 
     typedef std::vector<device::icf::Octave>::const_iterator  octIt_t;
-    int fitOctave(const std::vector<device::icf::Octave>& octs, const float& logFactor) const
+    static int fitOctave(const std::vector<device::icf::Octave>& octs, const float& logFactor)
     {
         float minAbsLog = FLT_MAX;
         int res =  0;
@@ -257,247 +433,61 @@ private:
             cv::gpu::integralBuffered(channel, sum, integralBuffer);
         }
     }
-};
 
-bool cv::gpu::SoftCascade::Filds::fill(const FileNode &root, const float mins, const float maxs)
-{
-    using namespace device::icf;
-    minScale = mins;
-    maxScale = maxs;
+public:
 
-    // cascade properties
-    static const char *const SC_STAGE_TYPE          = "stageType";
-    static const char *const SC_BOOST               = "BOOST";
+    // scales range
+    float minScale;
+    float maxScale;
 
-    static const char *const SC_FEATURE_TYPE        = "featureType";
-    static const char *const SC_ICF                 = "ICF";
+    int origObjWidth;
+    int origObjHeight;
 
-    static const char *const SC_ORIG_W              = "width";
-    static const char *const SC_ORIG_H              = "height";
+    const int shrinkage;
+    int downscales;
 
-    static const char *const SC_OCTAVES             = "octaves";
-    static const char *const SC_STAGES              = "stages";
-    static const char *const SC_FEATURES            = "features";
+    // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
+    GpuMat plane;
 
-    static const char *const SC_WEEK                = "weakClassifiers";
-    static const char *const SC_INTERNAL            = "internalNodes";
-    static const char *const SC_LEAF                = "leafValues";
+    // preallocated buffer for floating point operations
+    GpuMat fplane;
 
-    static const char *const SC_OCT_SCALE           = "scale";
-    static const char *const SC_OCT_STAGES          = "stageNum";
-    static const char *const SC_OCT_SHRINKAGE       = "shrinkingFactor";
+    // temporial mat for cvtColor
+    GpuMat luv;
 
-    static const char *const SC_STAGE_THRESHOLD     = "stageThreshold";
+    // 160x120x10
+    GpuMat shrunk;
 
-    static const char * const SC_F_CHANNEL          = "channel";
-    static const char * const SC_F_RECT             = "rect";
+    // temporial mat for integrall
+    GpuMat integralBuffer;
 
-    // only Ada Boost supported
-    std::string stageTypeStr = (string)root[SC_STAGE_TYPE];
-    CV_Assert(stageTypeStr == SC_BOOST);
+    // 161x121x10
+    GpuMat hogluv;
 
-    // only HOG-like integral channel features cupported
-    string featureTypeStr = (string)root[SC_FEATURE_TYPE];
-    CV_Assert(featureTypeStr == SC_ICF);
+    GpuMat detCounter;
 
-    origObjWidth = (int)root[SC_ORIG_W];
-    CV_Assert(origObjWidth  == ORIG_OBJECT_WIDTH);
+    // Cascade from xml
+    GpuMat octaves;
+    GpuMat stages;
+    GpuMat nodes;
+    GpuMat leaves;
+    GpuMat levels;
 
-    origObjHeight = (int)root[SC_ORIG_H];
-    CV_Assert(origObjHeight == ORIG_OBJECT_HEIGHT);
+    device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker;
 
-    FileNode fn = root[SC_OCTAVES];
-        if (fn.empty()) return false;
-
-    std::vector<Octave>  voctaves;
-    std::vector<float>   vstages;
-    std::vector<Node>    vnodes;
-    std::vector<float>   vleaves;
-    scales.clear();
-
-    FileNodeIterator it = fn.begin(), it_end = fn.end();
-    int feature_offset = 0;
-    ushort octIndex = 0;
-    ushort shrinkage = 1;
-
-    for (; it != it_end; ++it)
+    enum { BOOST = 0 };
+    enum
     {
-        FileNode fns = *it;
-        float scale = (float)fns[SC_OCT_SCALE];
-
-        bool isUPOctave = scale >= 1;
-
-        scales.push_back(scale);
-        ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
-        ushort2 size;
-        size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
-        size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
-        shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
-
-        Octave octave(octIndex, nstages, shrinkage, size, scale);
-        CV_Assert(octave.stages > 0);
-        voctaves.push_back(octave);
-
-        FileNode ffs = fns[SC_FEATURES];
-        if (ffs.empty()) return false;
-
-        FileNodeIterator ftrs = ffs.begin();
-
-        fns = fns[SC_STAGES];
-        if (fn.empty()) return false;
-
-        // for each stage (~ decision tree with H = 2)
-        FileNodeIterator st = fns.begin(), st_end = fns.end();
-        for (; st != st_end; ++st )
-        {
-            fns = *st;
-            vstages.push_back((float)fns[SC_STAGE_THRESHOLD]);
-
-            fns = fns[SC_WEEK];
-            FileNodeIterator ftr = fns.begin(), ft_end = fns.end();
-            for (; ftr != ft_end; ++ftr)
-            {
-                fns = (*ftr)[SC_INTERNAL];
-                FileNodeIterator inIt = fns.begin(), inIt_end = fns.end();
-                for (; inIt != inIt_end;)
-                {
-                    // int feature = (int)(*(inIt +=2)) + feature_offset;
-                    inIt +=3;
-                    // extract feature, Todo:check it
-                    uint th = saturate_cast<uint>((float)(*(inIt++)));
-                    cv::FileNode ftn = (*ftrs)[SC_F_RECT];
-                    cv::FileNodeIterator r_it = ftn.begin();
-                    uchar4 rect;
-                    rect.x = saturate_cast<uchar>((int)*(r_it++));
-                    rect.y = saturate_cast<uchar>((int)*(r_it++));
-                    rect.z = saturate_cast<uchar>((int)*(r_it++));
-                    rect.w = saturate_cast<uchar>((int)*(r_it++));
-
-                    if (isUPOctave)
-                    {
-                        rect.z -= rect.x;
-                        rect.w -= rect.y;
-                    }
-
-                    uint channel = saturate_cast<uint>((int)(*ftrs)[SC_F_CHANNEL]);
-                    vnodes.push_back(Node(rect, channel, th));
-                    ++ftrs;
-                }
-
-                fns = (*ftr)[SC_LEAF];
-                inIt = fns.begin(), inIt_end = fns.end();
-                for (; inIt != inIt_end; ++inIt)
-                    vleaves.push_back((float)(*inIt));
-            }
-        }
-
-        feature_offset += octave.stages * 3;
-        ++octIndex;
-    }
-
-    // upload in gpu memory
-    octaves.upload(cv::Mat(1, voctaves.size() * sizeof(Octave), CV_8UC1, (uchar*)&(voctaves[0]) ));
-    CV_Assert(!octaves.empty());
-
-    stages.upload(cv::Mat(vstages).reshape(1,1));
-    CV_Assert(!stages.empty());
-
-    nodes.upload(cv::Mat(1, vnodes.size() * sizeof(Node), CV_8UC1, (uchar*)&(vnodes[0]) ));
-    CV_Assert(!nodes.empty());
-
-    leaves.upload(cv::Mat(vleaves).reshape(1,1));
-    CV_Assert(!leaves.empty());
-
-    // compute levels
-    calcLevels(voctaves, FRAME_WIDTH, FRAME_HEIGHT, TOTAL_SCALES);
-    CV_Assert(!levels.empty());
-
-    invoker = device::icf::CascadeInvoker<device::icf::CascadePolicy>(levels, octaves, stages, nodes, leaves);
-
-    return true;
-}
-
-namespace {
-    struct CascadeIntrinsics
-    {
-        static const float lambda = 1.099f, a = 0.89f;
-
-        static float getFor(int channel, float scaling)
-        {
-            CV_Assert(channel < 10);
-
-            if (fabs(scaling - 1.f) < FLT_EPSILON)
-                return 1.f;
-
-            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
-            static const float A[2][2] =
-            {   //channel <= 6, otherwise
-                {        0.89f, 1.f}, // down
-                {        1.00f, 1.f}  // up
-            };
-
-            static const float B[2][2] =
-            {   //channel <= 6,  otherwise
-                { 1.099f / log(2), 2.f}, // down
-                {             0.f, 2.f}  // up
-            };
-
-            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
-            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
-
-            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
-            return a * pow(scaling, b);
-        }
+        FRAME_WIDTH        = 640,
+        FRAME_HEIGHT       = 480,
+        TOTAL_SCALES       = 55,
+        ORIG_OBJECT_WIDTH  = 64,
+        ORIG_OBJECT_HEIGHT = 128,
+        HOG_BINS           = 6,
+        LUV_BINS           = 3,
+        HOG_LUV_BINS       = 10
     };
-}
-
-inline void cv::gpu::SoftCascade::Filds::calcLevels(const std::vector<device::icf::Octave>& octs,
-                                                    int frameW, int frameH, int nscales)
-{
-    CV_Assert(nscales > 1);
-    using device::icf::Level;
-
-    std::vector<Level> vlevels;
-    float logFactor = (::log(maxScale) - ::log(minScale)) / (nscales -1);
-
-    float scale = minScale;
-    downscales = 0;
-    for (int sc = 0; sc < nscales; ++sc)
-    {
-        int width  = ::std::max(0.0f, frameW - (origObjWidth  * scale));
-        int height = ::std::max(0.0f, frameH - (origObjHeight * scale));
-
-        float logScale = ::log(scale);
-        int fit = fitOctave(octs, logScale);
-
-        Level level(fit, octs[fit], scale, width, height);
-        level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
-        level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
-
-        if (!width || !height)
-            break;
-        else
-        {
-            vlevels.push_back(level);
-            if (octs[fit].scale < 1) ++downscales;
-        }
-
-        if (::fabs(scale - maxScale) < FLT_EPSILON) break;
-        scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
-
-        // std::cout << "level " << sc
-        //           << " octeve "
-        //           << vlevels[sc].octave
-        //           << " relScale "
-        //           << vlevels[sc].relScale
-        //           << " " << vlevels[sc].shrScale
-        //           << " [" << (int)vlevels[sc].objSize.x
-        //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
-        // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
-    }
-
-    levels.upload(cv::Mat(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) ));
-}
+};
 
 cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
 
@@ -513,21 +503,15 @@ cv::gpu::SoftCascade::~SoftCascade()
 
 bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, const float maxScale)
 {
-    if (filds)
-        delete filds;
-    filds = 0;
+    if (filds) delete filds;
 
     cv::FileStorage fs(filename, FileStorage::READ);
     if (!fs.isOpened()) return false;
 
-    filds = new Filds;
-    Filds& flds = *filds;
-    if (!flds.fill(fs.getFirstTopLevelNode(), minScale, maxScale)) return false;
-    return true;
+    filds = Filds::parseCascade(fs.getFirstTopLevelNode(), minScale, maxScale);
+    return filds != 0;
 }
 
-//================================== synchronous version ============================================================//
-
 void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& rois,
                                 GpuMat& objects, const int /*rejectfactor*/, int specificScale) const
 {
@@ -562,7 +546,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat
 
 cv::Size cv::gpu::SoftCascade::getRoiSize() const
 {
-    return cv::Size(Filds::FRAME_WIDTH / 4, Filds::FRAME_HEIGHT / 4);
+    return cv::Size(Filds::FRAME_WIDTH / (*filds).shrinkage, Filds::FRAME_HEIGHT / (*filds).shrinkage);
 }
 
 #endif
\ No newline at end of file

From 2bcb8dbd83a67e27868fba2101bc443d9f892f5c Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Thu, 11 Oct 2012 21:56:36 +0400
Subject: [PATCH 047/155] refactor performance tests

---
 modules/gpu/perf/perf_softcascade.cpp | 182 ++++++++++++++++++++++++++
 1 file changed, 182 insertions(+)
 create mode 100644 modules/gpu/perf/perf_softcascade.cpp

diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
new file mode 100644
index 000000000..783089fcb
--- /dev/null
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -0,0 +1,182 @@
+#include "perf_precomp.hpp"
+
+#define GPU_PERF_TEST_P(fixture, name, params)  \
+    class fixture##_##name : public fixture {\
+     public:\
+      fixture##_##name() {}\
+     protected:\
+             virtual void __cpu();\
+        virtual void __gpu();\
+      virtual void PerfTestBody();\
+    };\
+    TEST_P(fixture##_##name, name /*perf*/){ RunPerfTestBody(); if (runOnGpu) __gpu(); else __cpu();}\
+    INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);\
+    void fixture##_##name::PerfTestBody()
+
+#define RUN_CPU(fixture, name)\
+    void fixture##_##name::__cpu()
+
+#define RUN_GPU(fixture, name)\
+    void fixture##_##name::__gpu()
+
+#define FAIL_NO_CPU(fixture, name)\
+void fixture##_##name::__cpu() { FAIL() << "No such CPU implementation analogy";}
+
+
+typedef std::tr1::tuple<std::string, std::string> fixture_t;
+typedef perf::TestBaseWithParam<fixture_t> SoftCascadeTest;
+
+GPU_PERF_TEST_P(SoftCascadeTest, detect,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
+{ }
+
+RUN_GPU(SoftCascadeTest, detect)
+{
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    rois.setTo(1);
+    cv::gpu::transpose(rois, trois);
+
+    cv::gpu::GpuMat curr = objectBoxes;
+    cascade.detectMultiScale(colored, trois, curr);
+
+    TEST_CYCLE()
+    {
+        curr = objectBoxes;
+        cascade.detectMultiScale(colored, trois, curr);
+    }
+}
+
+RUN_CPU(SoftCascadeTest, detect)
+{
+    cv::Mat colored = readImage(GET_PARAM(1));
+    ASSERT_FALSE(colored.empty());
+
+    cv::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
+
+    std::vector<cv::Rect> rois;
+
+    typedef cv::SoftCascade::Detection Detection;
+    std::vector<Detection>objectBoxes;
+    cascade.detectMultiScale(colored, rois, objectBoxes);
+
+    TEST_CYCLE()
+    {
+        cascade.detectMultiScale(colored, rois, objectBoxes);
+    }
+}
+
+static cv::Rect getFromTable(int idx)
+{
+    static const cv::Rect rois[] =
+    {
+        cv::Rect( 65,  20,  35, 80),
+        cv::Rect( 95,  35,  45, 40),
+        cv::Rect( 45,  35,  45, 40),
+        cv::Rect( 25,  27,  50, 45),
+        cv::Rect(100,  50,  45, 40),
+
+        cv::Rect( 60,  30,  45, 40),
+        cv::Rect( 40,  55,  50, 40),
+        cv::Rect( 48,  37,  72, 80),
+        cv::Rect( 48,  32,  85, 58),
+        cv::Rect( 48,   0,  32, 27)
+    };
+
+    return rois[idx];
+}
+
+typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
+typedef perf::TestBaseWithParam<roi_fixture_t> SoftCascadeTestRoi;
+
+GPU_PERF_TEST_P(SoftCascadeTestRoi, detectInRoi,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 5)))
+{}
+
+RUN_GPU(SoftCascadeTestRoi, detectInRoi)
+{
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(0);
+
+    int nroi = GET_PARAM(2);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
+    {
+        cv::Rect r = getFromTable(rng(10));
+        cv::gpu::GpuMat sub(rois, r);
+        sub.setTo(1);
+    }
+
+    cv::gpu::GpuMat trois;
+    cv::gpu::transpose(rois, trois);
+
+    cv::gpu::GpuMat curr = objectBoxes;
+    cascade.detectMultiScale(colored, trois, curr);
+
+    TEST_CYCLE()
+    {
+        curr = objectBoxes;
+        cascade.detectMultiScale(colored, trois, curr);
+    }
+}
+
+FAIL_NO_CPU(SoftCascadeTestRoi, detectInRoi)
+
+
+GPU_PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+        testing::Range(0, 10)))
+{}
+
+RUN_GPU(SoftCascadeTestRoi, detectEachRoi)
+{
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(0);
+
+    int idx = GET_PARAM(2);
+    cv::Rect r = getFromTable(idx);
+    cv::gpu::GpuMat sub(rois, r);
+    sub.setTo(1);
+
+    cv::gpu::GpuMat curr = objectBoxes;
+    cv::gpu::GpuMat trois;
+    cv::gpu::transpose(rois, trois);
+
+    cascade.detectMultiScale(colored, trois, curr);
+
+    TEST_CYCLE()
+    {
+        curr = objectBoxes;
+        cascade.detectMultiScale(colored, trois, curr);
+    }
+}
+
+FAIL_NO_CPU(SoftCascadeTestRoi, detectEachRoi)
\ No newline at end of file

From 022a8b9698c0c488c03fdfb83b47bf1675b6712a Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 15 Oct 2012 15:27:33 +0400
Subject: [PATCH 048/155] fix rounding bug in Level creation

---
 modules/gpu/src/icf.hpp         | 11 +----------
 modules/gpu/src/imgproc.cpp     |  2 +-
 modules/gpu/src/softcascade.cpp | 12 +++++++++++-
 3 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 06c81149e..d829012c8 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -81,16 +81,7 @@ struct __align__(8) Level //is actually 24 bytes
     uchar2 workRect;
     uchar2 objSize;
 
-    Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-    :  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
-    {
-        workRect.x = round(w / (float)oct.shrinkage);
-        workRect.y = round(h / (float)oct.shrinkage);
-
-        objSize.x  = round(oct.size.x * relScale);
-        objSize.y  = round(oct.size.y * relScale);
-    }
-
+    Level(int idx, const Octave& oct, const float scale, const int w, const int h);
     __device Level(){}
 };
 
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index 0bf9c81c2..df02213b1 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -553,7 +553,7 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
 
     src.locateROI(whole, offset);
 
-    if (info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048)
+    if (false && info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048)
     {
         GpuMat srcAlligned;
 
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index fc7114b5f..e5d8cb9fb 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -65,6 +65,16 @@ cv::Size cv::gpu::SoftCascade::getRoiSize() const { throw_nogpu(); return cv::Si
 
 #include <icf.hpp>
 
+cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale, const int w, const int h)
+:  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+{
+    workRect.x = round(w / (float)oct.shrinkage);
+    workRect.y = round(h / (float)oct.shrinkage);
+
+    objSize.x  = cv::saturate_cast<uchar>(oct.size.x * relScale);
+    objSize.y  = cv::saturate_cast<uchar>(oct.size.y * relScale);
+}
+
 namespace cv { namespace gpu { namespace device {
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
@@ -72,7 +82,7 @@ namespace icf {
 }
 namespace imgproc
 {
-    void meanShiftFiltering_gpu(const PtrStepSzb& src, PtrStepSzb dst, int sp, int sr, int maxIter, float eps, cudaStream_t stream);
+    void shfl_integral_gpu(PtrStepSzb img, PtrStepSz<unsigned int> integral, cudaStream_t stream);
 }
 }}}
 

From ca81628a9a3fe8e82f5ba3348a3036e5b6475e45 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 15 Oct 2012 17:38:21 +0400
Subject: [PATCH 049/155] fix retrieval of detections count

---
 modules/gpu/src/cuda/isf-sc.cu        | 2 +-
 modules/gpu/src/softcascade.cpp       | 2 +-
 modules/gpu/test/test_softcascade.cpp | 4 ++++
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 74e47ba19..7aef41abc 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -313,7 +313,7 @@ namespace icf {
         dim3 block(32, 8);
         dim3 grid(fw, fh / 8, (scale == -1) ? downscales : 1);
 
-        uint* ctr = (uint*)counter.ptr();
+        uint* ctr = (uint*)(counter.ptr(0));
         Detection* det = (Detection*)objects.ptr();
         uint max_det = objects.cols / sizeof(Detection);
 
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index e5d8cb9fb..560c25196 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -541,7 +541,7 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
     flds.detect(specificScale, rois, objects, 0);
 
     cv::Mat out(flds.detCounter);
-    int ndetections = *(out.data);
+    int ndetections = *(out.ptr<int>(0));
 
     if (! ndetections)
         objects = GpuMat();
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 04fa9b181..04c38557c 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -257,5 +257,9 @@ TEST(SoftCascadeTest, detect)
     cv::gpu::transpose(rois, trois);
 
     cascade.detectMultiScale(colored, trois, objectBoxes);
+
+    typedef cv::gpu::SoftCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    ASSERT_EQ(detections.cols / sizeof(Detection) ,3670U);
 }
 #endif
\ No newline at end of file

From fa55d51b6ae616b90a036de7a231335f1fce475f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 15 Oct 2012 18:13:58 +0400
Subject: [PATCH 050/155] add sanity check to performance tests for soft
 cascade

---
 modules/gpu/perf/perf_softcascade.cpp | 59 ++++++++++++++++++++++++---
 1 file changed, 53 insertions(+), 6 deletions(-)

diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 783089fcb..d379d7fe5 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -5,7 +5,7 @@
      public:\
       fixture##_##name() {}\
      protected:\
-             virtual void __cpu();\
+        virtual void __cpu();\
         virtual void __gpu();\
       virtual void PerfTestBody();\
     };\
@@ -22,6 +22,44 @@
 #define FAIL_NO_CPU(fixture, name)\
 void fixture##_##name::__cpu() { FAIL() << "No such CPU implementation analogy";}
 
+namespace {
+    struct DetectionLess
+    {
+        bool operator()(const cv::gpu::SoftCascade::Detection& a,
+            const cv::gpu::SoftCascade::Detection& b) const
+        {
+            if (a.x != b.x) return a.x < b.x;
+            else if (a.y != b.y) return a.y < b.y;
+            else if (a.w != b.w) return a.w < b.w;
+            else return a.h < b.h;
+        }
+
+        bool operator()(const cv::SoftCascade::Detection& a,
+            const cv::SoftCascade::Detection& b) const
+        {
+            const cv::Rect& ra = a.rect;
+            const cv::Rect& rb = b.rect;
+
+            if (ra.x != rb.x) return ra.x < rb.x;
+            else if (ra.y != rb.y) return ra.y < rb.y;
+            else if (ra.width != rb.width) return ra.width < rb.width;
+            else return ra.height < rb.height;
+        }
+    };
+
+    cv::Mat sortDetections(cv::gpu::GpuMat& objects)
+    {
+        cv::Mat detections(objects);
+
+        typedef cv::gpu::SoftCascade::Detection Detection;
+        Detection* begin = (Detection*)(detections.ptr<char>(0));
+        Detection* end = (Detection*)(detections.ptr<char>(0) + detections.cols);
+        std::sort(begin, end, DetectionLess());
+
+        return detections;
+    }
+}
+
 
 typedef std::tr1::tuple<std::string, std::string> fixture_t;
 typedef perf::TestBaseWithParam<fixture_t> SoftCascadeTest;
@@ -41,7 +79,7 @@ RUN_GPU(SoftCascadeTest, detect)
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
 
-    cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SoftCascade::Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
     rois.setTo(1);
     cv::gpu::transpose(rois, trois);
 
@@ -53,6 +91,8 @@ RUN_GPU(SoftCascadeTest, detect)
         curr = objectBoxes;
         cascade.detectMultiScale(colored, trois, curr);
     }
+
+    SANITY_CHECK(sortDetections(curr));
 }
 
 RUN_CPU(SoftCascadeTest, detect)
@@ -66,13 +106,16 @@ RUN_CPU(SoftCascadeTest, detect)
     std::vector<cv::Rect> rois;
 
     typedef cv::SoftCascade::Detection Detection;
-    std::vector<Detection>objectBoxes;
-    cascade.detectMultiScale(colored, rois, objectBoxes);
+    std::vector<Detection>objects;
+    cascade.detectMultiScale(colored, rois, objects);
 
     TEST_CYCLE()
     {
-        cascade.detectMultiScale(colored, rois, objectBoxes);
+        cascade.detectMultiScale(colored, rois, objects);
     }
+
+    std::sort(objects.begin(), objects.end(), DetectionLess());
+    SANITY_CHECK(objects);
 }
 
 static cv::Rect getFromTable(int idx)
@@ -137,6 +180,8 @@ RUN_GPU(SoftCascadeTestRoi, detectInRoi)
         curr = objectBoxes;
         cascade.detectMultiScale(colored, trois, curr);
     }
+
+    SANITY_CHECK(sortDetections(curr));
 }
 
 FAIL_NO_CPU(SoftCascadeTestRoi, detectInRoi)
@@ -177,6 +222,8 @@ RUN_GPU(SoftCascadeTestRoi, detectEachRoi)
         curr = objectBoxes;
         cascade.detectMultiScale(colored, trois, curr);
     }
+
+    SANITY_CHECK(sortDetections(curr));
 }
 
-FAIL_NO_CPU(SoftCascadeTestRoi, detectEachRoi)
\ No newline at end of file
+FAIL_NO_CPU(SoftCascadeTestRoi, detectEachRoi)

From 2bd35c4358400657b0b6b1a47905152410e01628 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 15 Oct 2012 21:55:57 +0400
Subject: [PATCH 051/155] add support for precomputed integrals

---
 modules/gpu/perf/perf_softcascade.cpp | 56 +++++++++++++++++++++++++--
 modules/gpu/src/softcascade.cpp       | 15 +++++--
 modules/gpu/test/test_softcascade.cpp | 33 ++++++++++++++++
 3 files changed, 96 insertions(+), 8 deletions(-)

diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index d379d7fe5..582561c7c 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -9,7 +9,7 @@
         virtual void __gpu();\
       virtual void PerfTestBody();\
     };\
-    TEST_P(fixture##_##name, name /*perf*/){ RunPerfTestBody(); if (runOnGpu) __gpu(); else __cpu();}\
+    TEST_P(fixture##_##name, name /*perf*/){ RunPerfTestBody(); if (PERF_RUN_GPU()) __gpu(); else __cpu();}\
     INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);\
     void fixture##_##name::PerfTestBody()
 
@@ -19,7 +19,7 @@
 #define RUN_GPU(fixture, name)\
     void fixture##_##name::__gpu()
 
-#define FAIL_NO_CPU(fixture, name)\
+#define NO_CPU(fixture, name)\
 void fixture##_##name::__cpu() { FAIL() << "No such CPU implementation analogy";}
 
 namespace {
@@ -184,7 +184,7 @@ RUN_GPU(SoftCascadeTestRoi, detectInRoi)
     SANITY_CHECK(sortDetections(curr));
 }
 
-FAIL_NO_CPU(SoftCascadeTestRoi, detectInRoi)
+NO_CPU(SoftCascadeTestRoi, detectInRoi)
 
 
 GPU_PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
@@ -226,4 +226,52 @@ RUN_GPU(SoftCascadeTestRoi, detectEachRoi)
     SANITY_CHECK(sortDetections(curr));
 }
 
-FAIL_NO_CPU(SoftCascadeTestRoi, detectEachRoi)
+NO_CPU(SoftCascadeTestRoi, detectEachRoi)
+
+GPU_PERF_TEST_P(SoftCascadeTest, detectOnIntegral,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/integrals.xml"))))
+{ }
+
+    static std::string itoa(long i)
+    {
+        static char s[65];
+        sprintf(s, "%ld", i);
+        return std::string(s);
+    }
+
+RUN_GPU(SoftCascadeTest, detectOnIntegral)
+{
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
+    {
+        cv::Mat channel;
+        fs[std::string("channel") + itoa(i)] >> channel;
+        cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
+
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SoftCascade::Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    rois.setTo(1);
+    cv::gpu::transpose(rois, trois);
+
+    cv::gpu::GpuMat curr = objectBoxes;
+    cascade.detectMultiScale(hogluv, trois, curr);
+
+    TEST_CYCLE()
+    {
+        curr = objectBoxes;
+        cascade.detectMultiScale(hogluv, trois, curr);
+    }
+
+    SANITY_CHECK(sortDetections(curr));
+}
+
+NO_CPU(SoftCascadeTest, detectOnIntegral)
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 560c25196..d9519e873 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -526,17 +526,24 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
                                 GpuMat& objects, const int /*rejectfactor*/, int specificScale) const
 {
     // only color images are supperted
-    CV_Assert(colored.type() == CV_8UC3);
+    CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
     // we guess user knows about shrincage
     CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
 
-    // only this window size allowed
-    CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
 
     Filds& flds = *filds;
 
-    flds.preprocess(colored);
+    if (colored.type() == CV_8UC3)
+    {
+        // only this window size allowed
+        CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
+        flds.preprocess(colored);
+    }
+    else
+    {
+        colored.copyTo(flds.hogluv);
+    }
 
     flds.detect(specificScale, rois, objects, 0);
 
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 04c38557c..bf880297b 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -262,4 +262,37 @@ TEST(SoftCascadeTest, detect)
     cv::Mat detections(objectBoxes);
     ASSERT_EQ(detections.cols / sizeof(Detection) ,3670U);
 }
+
+TEST(SoftCascadeTest, detectOnIntegral)
+{
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SoftCascade cascade;
+    ASSERT_TRUE(cascade.load(xml));
+
+    std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
+    cv::FileStorage fs(intPath, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
+    {
+        cv::Mat channel;
+        fs[std::string("channel") + SoftCascadeTest::itoa(i)] >> channel;
+        GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
+
+    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    rois.setTo(1);
+
+    cv::gpu::GpuMat trois;
+    cv::gpu::transpose(rois, trois);
+
+    cascade.detectMultiScale(hogluv, trois, objectBoxes);
+
+    typedef cv::gpu::SoftCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+
+    ASSERT_EQ(detections.cols / sizeof(Detection) ,2042U);
+}
 #endif
\ No newline at end of file

From fba62c9251053410adc71ead3d9e594567426242 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 3 Nov 2012 18:03:31 +0400
Subject: [PATCH 052/155] fix compilation problem after rebase

---
 modules/gpu/perf/perf_objdetect.cpp   | 242 +-------------------------
 modules/gpu/perf/perf_softcascade.cpp |  56 +++---
 2 files changed, 31 insertions(+), 267 deletions(-)

diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index ced8ee17d..6d040ac02 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -89,244 +89,6 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
     SANITY_CHECK(found_locations);
 }
 
-//================================================= ICF SoftCascade =================================================//
-
-typedef pair<string, string> pair_string;
-DEF_PARAM_TEST_1(SoftCascade, pair_string);
-
-
-// struct SoftCascadeTest : public perf::TestBaseWithParam<roi_fixture_t>
-// {
-//     typedef cv::gpu::SoftCascade::Detection detection_t;
-//     static cv::Rect getFromTable(int idx)
-//     {
-//         static const cv::Rect rois[] =
-//         {
-//             cv::Rect( 65,  20,  35, 80),
-//             cv::Rect( 95,  35,  45, 40),
-//             cv::Rect( 45,  35,  45, 40),
-//             cv::Rect( 25,  27,  50, 45),
-//             cv::Rect(100,  50,  45, 40),
-
-//             cv::Rect( 60,  30,  45, 40),
-//             cv::Rect( 40,  55,  50, 40),
-//             cv::Rect( 48,  37,  72, 80),
-//             cv::Rect( 48,  32,  85, 58),
-//             cv::Rect( 48,   0,  32, 27)
-//         };
-
-//         return rois[idx];
-//     }
-
-//     static std::string itoa(long i)
-//     {
-//         static char s[65];
-//         sprintf(s, "%ld", i);
-//         return std::string(s);
-//     }
-
-//     static std::string getImageName(int level)
-//     {
-//         time_t rawtime;
-//         struct tm * timeinfo;
-//         char buffer [80];
-
-//         time ( &rawtime );
-//         timeinfo = localtime ( &rawtime );
-
-//         strftime (buffer,80,"%Y-%m-%d--%H-%M-%S",timeinfo);
-//         return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
-//     }
-
-//     static void print(std::ostream &out, const detection_t& d)
-//     {
-//         out << "\x1b[32m[ detection]\x1b[0m ("
-//             << std::setw(4)  << d.x
-//             << " "
-//             << std::setw(4)  << d.y
-//             << ") ("
-//             << std::setw(4)  << d.w
-//             << " "
-//             << std::setw(4)  << d.h
-//             << ") "
-//             << std::setw(12) << d.confidence
-//             <<  std::endl;
-//     }
-
-//     static void printTotal(std::ostream &out, int detbytes)
-//     {
-//         out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(detection_t)) << std::endl;
-//     }
-
-//     static void writeResult(const cv::Mat& result, const int level)
-//     {
-//         std::string path = cv::tempfile(getImageName(level).c_str());
-//         cv::imwrite(path, result);
-//         std::cout << "\x1b[32m" << "[          ]" << std::endl << "[ stored in]"<< "\x1b[0m" << path << std::endl;
-//     }
-// };
-
-typedef std::tr1::tuple<std::string, std::string> fixture_t;
-typedef perf::TestBaseWithParam<fixture_t> SoftCascadeTest;
-
-PERF_TEST_P(SoftCascadeTest, detect,
-    testing::Combine(
-        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
-{
-    if (runOnGpu)
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
-
-        cv::gpu::GpuMat objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
-        rois.setTo(1);
-        cv::gpu::transpose(rois, trois);
-
-        cv::gpu::GpuMat curr = objectBoxes;
-        cascade.detectMultiScale(colored, trois, curr);
-
-        TEST_CYCLE()
-        {
-            curr = objectBoxes;
-            cascade.detectMultiScale(colored, trois, curr);
-        }
-    }
-    else
-    {
-        cv::Mat colored = readImage(GET_PARAM(1));
-        ASSERT_FALSE(colored.empty());
-
-        cv::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
-
-        std::vector<cv::Rect> rois;
-
-        typedef cv::SoftCascade::Detection Detection;
-        std::vector<Detection>objectBoxes;
-        cascade.detectMultiScale(colored, rois, objectBoxes);
-
-        TEST_CYCLE()
-        {
-            cascade.detectMultiScale(colored, rois, objectBoxes);
-        }
-    }
-}
-
-static cv::Rect getFromTable(int idx)
-{
-    static const cv::Rect rois[] =
-    {
-        cv::Rect( 65,  20,  35, 80),
-        cv::Rect( 95,  35,  45, 40),
-        cv::Rect( 45,  35,  45, 40),
-        cv::Rect( 25,  27,  50, 45),
-        cv::Rect(100,  50,  45, 40),
-
-        cv::Rect( 60,  30,  45, 40),
-        cv::Rect( 40,  55,  50, 40),
-        cv::Rect( 48,  37,  72, 80),
-        cv::Rect( 48,  32,  85, 58),
-        cv::Rect( 48,   0,  32, 27)
-    };
-
-    return rois[idx];
-}
-
-typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
-typedef perf::TestBaseWithParam<roi_fixture_t> SoftCascadeTestRoi;
-
-PERF_TEST_P(SoftCascadeTestRoi, detectInRoi,
-    testing::Combine(
-        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-        testing::Range(0, 5)))
-{
-    if (runOnGpu)
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
-
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
-        rois.setTo(0);
-
-        int nroi = GET_PARAM(2);
-        cv::RNG rng;
-        for (int i = 0; i < nroi; ++i)
-        {
-            cv::Rect r = getFromTable(rng(10));
-            cv::gpu::GpuMat sub(rois, r);
-            sub.setTo(1);
-        }
-
-        cv::gpu::GpuMat trois;
-        cv::gpu::transpose(rois, trois);
-
-        cv::gpu::GpuMat curr = objectBoxes;
-        cascade.detectMultiScale(colored, trois, curr);
-
-        TEST_CYCLE()
-        {
-            curr = objectBoxes;
-            cascade.detectMultiScale(colored, trois, curr);
-        }
-    }
-    else
-    {
-        FAIL();
-    }
-}
-
-PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
-    testing::Combine(
-        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-        testing::Range(0, 10)))
-{
-    if (runOnGpu)
-    {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SoftCascade cascade;
-        ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
-
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
-        rois.setTo(0);
-
-        int idx = GET_PARAM(2);
-        cv::Rect r = getFromTable(idx);
-        cv::gpu::GpuMat sub(rois, r);
-        sub.setTo(1);
-
-        cv::gpu::GpuMat curr = objectBoxes;
-        cv::gpu::GpuMat trois;
-        cv::gpu::transpose(rois, trois);
-
-        cascade.detectMultiScale(colored, trois, curr);
-
-        TEST_CYCLE()
-        {
-            curr = objectBoxes;
-            cascade.detectMultiScale(colored, rois, curr);
-        }
-    }
-    else
-    {
-        FAIL();
-    }
-}
-
-
 ///////////////////////////////////////////////////////////////
 // HaarClassifier
 
@@ -383,7 +145,7 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     cv::Mat img = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
 
-    if (runOnGpu)
+    if (PERF_RUN_GPU())
     {
         cv::gpu::CascadeClassifier_GPU d_cascade;
         ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
@@ -418,4 +180,4 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     }
 }
 
-} // namespace
+} // namespace
\ No newline at end of file
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 582561c7c..9b53b2e84 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -34,17 +34,17 @@ namespace {
             else return a.h < b.h;
         }
 
-        bool operator()(const cv::SoftCascade::Detection& a,
-            const cv::SoftCascade::Detection& b) const
-        {
-            const cv::Rect& ra = a.rect;
-            const cv::Rect& rb = b.rect;
+        // bool operator()(const cv::SoftCascade::Detection& a,
+        //     const cv::SoftCascade::Detection& b) const
+        // {
+        //     const cv::Rect& ra = a.rect;
+        //     const cv::Rect& rb = b.rect;
 
-            if (ra.x != rb.x) return ra.x < rb.x;
-            else if (ra.y != rb.y) return ra.y < rb.y;
-            else if (ra.width != rb.width) return ra.width < rb.width;
-            else return ra.height < rb.height;
-        }
+        //     if (ra.x != rb.x) return ra.x < rb.x;
+        //     else if (ra.y != rb.y) return ra.y < rb.y;
+        //     else if (ra.width != rb.width) return ra.width < rb.width;
+        //     else return ra.height < rb.height;
+        // }
     };
 
     cv::Mat sortDetections(cv::gpu::GpuMat& objects)
@@ -95,28 +95,30 @@ RUN_GPU(SoftCascadeTest, detect)
     SANITY_CHECK(sortDetections(curr));
 }
 
-RUN_CPU(SoftCascadeTest, detect)
-{
-    cv::Mat colored = readImage(GET_PARAM(1));
-    ASSERT_FALSE(colored.empty());
+NO_CPU(SoftCascadeTest, detect)
 
-    cv::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
+// RUN_CPU(SoftCascadeTest, detect)
+// {
+//     cv::Mat colored = readImage(GET_PARAM(1));
+//     ASSERT_FALSE(colored.empty());
 
-    std::vector<cv::Rect> rois;
+//     cv::SoftCascade cascade;
+//     ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
 
-    typedef cv::SoftCascade::Detection Detection;
-    std::vector<Detection>objects;
-    cascade.detectMultiScale(colored, rois, objects);
+//     std::vector<cv::Rect> rois;
 
-    TEST_CYCLE()
-    {
-        cascade.detectMultiScale(colored, rois, objects);
-    }
+//     typedef cv::SoftCascade::Detection Detection;
+//     std::vector<Detection>objects;
+//     cascade.detectMultiScale(colored, rois, objects);
 
-    std::sort(objects.begin(), objects.end(), DetectionLess());
-    SANITY_CHECK(objects);
-}
+//     TEST_CYCLE()
+//     {
+//         cascade.detectMultiScale(colored, rois, objects);
+//     }
+
+//     std::sort(objects.begin(), objects.end(), DetectionLess());
+//     SANITY_CHECK(objects);
+// }
 
 static cv::Rect getFromTable(int idx)
 {

From ac5cd4827908952bf29a40879c1b4490c6d3127d Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sun, 4 Nov 2012 03:29:20 +0400
Subject: [PATCH 053/155] add DeviceInfo parameter to the soft cascade tests

---
 modules/gpu/test/test_softcascade.cpp | 67 ++++++++++++++++-----------
 1 file changed, 39 insertions(+), 28 deletions(-)

diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index bf880297b..fb936be88 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -68,12 +68,10 @@ using cv::gpu::GpuMat;
     INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);  \
     void fixture##_##name::body()
 
+namespace {
 
-typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
+    typedef cv::gpu::SoftCascade::Detection Detection;
 
-struct SoftCascadeTest : public ::testing::TestWithParam<roi_fixture_t>
-{
-    typedef cv::gpu::SoftCascade::Detection detection_t;
     static cv::Rect getFromTable(int idx)
     {
         static const cv::Rect rois[] =
@@ -114,7 +112,7 @@ struct SoftCascadeTest : public ::testing::TestWithParam<roi_fixture_t>
         return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
     }
 
-    static void print(std::ostream &out, const detection_t& d)
+    static void print(std::ostream &out, const Detection& d)
     {
         out << "\x1b[32m[ detection]\x1b[0m ("
             << std::setw(4)  << d.x
@@ -131,7 +129,7 @@ struct SoftCascadeTest : public ::testing::TestWithParam<roi_fixture_t>
 
     static void printTotal(std::ostream &out, int detbytes)
     {
-        out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(detection_t)) << std::endl;
+        out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl;
     }
 
     static void writeResult(const cv::Mat& result, const int level)
@@ -140,24 +138,27 @@ struct SoftCascadeTest : public ::testing::TestWithParam<roi_fixture_t>
         cv::imwrite(path, result);
         std::cout << "\x1b[32m" << "[          ]" << std::endl << "[ stored in]"<< "\x1b[0m" << path << std::endl;
     }
-};
+}
 
-GPU_TEST_P(SoftCascadeTest, detectInROI,
+typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SoftCascadeTestRoi;
+GPU_TEST_P(SoftCascadeTestRoi, detect,
     testing::Combine(
+        ALL_DEVICES,
         testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1));
+    cv::gpu::setDevice(GET_PARAM(0).deviceID());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
     ASSERT_FALSE(coloredCpu.empty());
 
     cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(cvtest::TS::ptr()->get_data_path() + GET_PARAM(0)));
+    ASSERT_TRUE(cascade.load(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1)));
 
     GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
     rois.setTo(0);
 
-    int nroi = GET_PARAM(2);
+    int nroi = GET_PARAM(3);
     cv::Mat result(coloredCpu);
     cv::RNG rng;
     for (int i = 0; i < nroi; ++i)
@@ -173,16 +174,15 @@ GPU_TEST_P(SoftCascadeTest, detectInROI,
 
     cascade.detectMultiScale(colored, trois, objectBoxes);
 
-    ///
     cv::Mat dt(objectBoxes);
-    typedef cv::gpu::SoftCascade::Detection detection_t;
+    typedef cv::gpu::SoftCascade::Detection Detection;
 
-    detection_t* dts = (detection_t*)dt.data;
+    Detection* dts = (Detection*)dt.data;
 
     printTotal(std::cout, dt.cols);
-    for (int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
+    for (int i = 0; i  < (int)(dt.cols / sizeof(Detection)); ++i)
     {
-        detection_t d = dts[i];
+        Detection d = dts[i];
         print(std::cout, d);
         cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
     }
@@ -190,39 +190,43 @@ GPU_TEST_P(SoftCascadeTest, detectInROI,
     SHOW(result);
 }
 
-GPU_TEST_P(SoftCascadeTest, detectInLevel,
+typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SoftCascadeTestLevel;
+GPU_TEST_P(SoftCascadeTestLevel, detect,
         testing::Combine(
+        ALL_DEVICES,
         testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 47)
         ))
 {
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + GET_PARAM(0);
+    cv::gpu::setDevice(GET_PARAM(0).deviceID());
+
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + GET_PARAM(1);
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
 
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1));
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
     ASSERT_FALSE(coloredCpu.empty());
 
-    typedef cv::gpu::SoftCascade::Detection detection_t;
-    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(detection_t), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    typedef cv::gpu::SoftCascade::Detection Detection;
+    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
     rois.setTo(1);
 
     cv::gpu::GpuMat trois;
     cv::gpu::transpose(rois, trois);
 
-    int level = GET_PARAM(2);
+    int level = GET_PARAM(3);
     cascade.detectMultiScale(colored, trois, objectBoxes, 1, level);
 
     cv::Mat dt(objectBoxes);
 
-    detection_t* dts = (detection_t*)dt.data;
+    Detection* dts = (Detection*)dt.data;
     cv::Mat result(coloredCpu);
 
     printTotal(std::cout, dt.cols);
-    for (int i = 0; i  < (int)(dt.cols / sizeof(detection_t)); ++i)
+    for (int i = 0; i  < (int)(dt.cols / sizeof(Detection)); ++i)
     {
-        detection_t d = dts[i];
+        Detection d = dts[i];
         print(std::cout, d);
         cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
     }
@@ -238,8 +242,12 @@ TEST(SoftCascadeTest, readCascade)
     ASSERT_TRUE(cascade.load(xml));
 }
 
-TEST(SoftCascadeTest, detect)
+typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SoftCascadeTestAll;
+GPU_TEST_P(SoftCascadeTestAll, detect,
+        ALL_DEVICES
+        )
 {
+    cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
@@ -263,8 +271,11 @@ TEST(SoftCascadeTest, detect)
     ASSERT_EQ(detections.cols / sizeof(Detection) ,3670U);
 }
 
-TEST(SoftCascadeTest, detectOnIntegral)
+GPU_TEST_P(SoftCascadeTestAll, detectOnIntegral,
+        ALL_DEVICES
+        )
 {
+    cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SoftCascade cascade;
     ASSERT_TRUE(cascade.load(xml));
@@ -277,7 +288,7 @@ TEST(SoftCascadeTest, detectOnIntegral)
     for (int i = 0; i < 10; ++i)
     {
         cv::Mat channel;
-        fs[std::string("channel") + SoftCascadeTest::itoa(i)] >> channel;
+        fs[std::string("channel") + itoa(i)] >> channel;
         GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
         gchannel.upload(channel);
     }

From df392cc830df738cdb8f0f2a2398fad684752f3e Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 5 Nov 2012 13:52:24 +0400
Subject: [PATCH 054/155] use fast integral for soft cascade

---
 modules/gpu/src/cuda/integral_image.cu | 83 ++++++++++++++++++++++++++
 modules/gpu/src/cuda/isf-sc.cu         |  4 +-
 modules/gpu/src/softcascade.cpp        | 31 +++++-----
 modules/gpu/test/test_softcascade.cpp  |  1 +
 4 files changed, 102 insertions(+), 17 deletions(-)

diff --git a/modules/gpu/src/cuda/integral_image.cu b/modules/gpu/src/cuda/integral_image.cu
index 558f9085d..5bd35bdc7 100644
--- a/modules/gpu/src/cuda/integral_image.cu
+++ b/modules/gpu/src/cuda/integral_image.cu
@@ -383,6 +383,89 @@ namespace cv { namespace gpu { namespace device
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
         }
+
+        __global__ void shfl_integral_vertical(PtrStepSz<unsigned int> buffer, PtrStepSz<unsigned int> integral)
+        {
+        #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 300)
+            __shared__ unsigned int sums[32][9];
+
+            const int tidx = blockIdx.x * blockDim.x + threadIdx.x;
+            const int lane_id = tidx % 8;
+
+            if (tidx >= integral.cols)
+                return;
+
+            sums[threadIdx.x][threadIdx.y] = 0;
+            __syncthreads();
+
+            unsigned int stepSum = 0;
+
+            for (int y = threadIdx.y; y < integral.rows; y += blockDim.y)
+            {
+                unsigned int* p = buffer.ptr(y) + tidx;
+                unsigned int* dst = integral.ptr(y + 1) + tidx + 1;
+
+                unsigned int sum = *p;
+
+                sums[threadIdx.x][threadIdx.y] = sum;
+                __syncthreads();
+
+                // place into SMEM
+                // shfl scan reduce the SMEM, reformating so the column
+                // sums are computed in a warp
+                // then read out properly
+                const int j = threadIdx.x % 8;
+                const int k = threadIdx.x / 8 + threadIdx.y * 4;
+
+                int partial_sum = sums[k][j];
+
+                for (int i = 1; i <= 8; i *= 2)
+                {
+                    int n = __shfl_up(partial_sum, i, 32);
+
+                    if (lane_id >= i)
+                        partial_sum += n;
+                }
+
+                sums[k][j] = partial_sum;
+                __syncthreads();
+
+                if (threadIdx.y > 0)
+                    sum += sums[threadIdx.x][threadIdx.y - 1];
+
+                sum += stepSum;
+                stepSum += sums[threadIdx.x][blockDim.y - 1];
+
+                __syncthreads();
+
+                *dst = sum;
+            }
+        #endif
+        }
+
+        // used for frame preprocessing before Soft Cascade evaluation: no synchronization needed
+        // ToDo: partial dy
+        void shfl_integral_gpu_buffered(PtrStepSzb img, PtrStepSz<uint4> buffer, PtrStepSz<unsigned int> integral,
+            int blockStep, cudaStream_t stream)
+        {
+            {
+                const int block = blockStep;
+                const int grid = img.rows;
+
+                cudaSafeCall( cudaFuncSetCacheConfig(shfl_integral_horizontal, cudaFuncCachePreferL1) );
+
+                shfl_integral_horizontal<<<grid, block, 0, stream>>>((PtrStepSz<uint4>) img, buffer);
+                cudaSafeCall( cudaGetLastError() );
+            }
+
+            {
+                const dim3 block(32, 8);
+                const dim3 grid(divUp(integral.cols, block.x), 1);
+
+                shfl_integral_vertical<<<grid, block, 0, stream>>>((PtrStepSz<uint>)buffer, integral);
+                cudaSafeCall( cudaGetLastError() );
+            }
+        }
     }
 }}}
 
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 7aef41abc..3391bb1a0 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -198,14 +198,14 @@ namespace icf {
             Node node = nodes[nId];
 
             float threshold = rescale<isUp>(level, node);
-            int sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
+            int sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
 
             int next = 1 + (int)(sum >= threshold);
             dprintf("%d: go: %d (%d >= %f)\n\n" ,threadIdx.x, next, sum, threshold);
 
             node = nodes[nId + next];
             threshold = rescale<isUp>(level, node);
-            sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
+            sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
 
             const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
             float impact = leaves[(st + threadIdx.x) * 4 + lShift];
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index d9519e873..2d43a5440 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -76,14 +76,20 @@ cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale
 }
 
 namespace cv { namespace gpu { namespace device {
+
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins);
 }
-namespace imgproc
-{
-    void shfl_integral_gpu(PtrStepSzb img, PtrStepSz<unsigned int> integral, cudaStream_t stream);
+
+namespace imgproc {
+    void shfl_integral_gpu_buffered(PtrStepSzb, PtrStepSz<uint4>, PtrStepSz<unsigned int>, int, cudaStream_t);
+
+    template <typename T>
+    void resize_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy,
+                    PtrStepSzb dst, int interpolation, cudaStream_t stream);
 }
+
 }}}
 
 struct cv::gpu::SoftCascade::Filds
@@ -319,9 +325,13 @@ struct cv::gpu::SoftCascade::Filds
         plane.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
         fplane.create(FRAME_HEIGHT * 6, FRAME_WIDTH, CV_32FC1);
         luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
+
         shrunk.create(FRAME_HEIGHT / shr * HOG_LUV_BINS, FRAME_WIDTH / shr, CV_8UC1);
-        integralBuffer.create(1 , (shrunk.rows + 1) * HOG_LUV_BINS * (shrunk.cols + 1), CV_32SC1);
-        hogluv.create((FRAME_HEIGHT / shr + 1) * HOG_LUV_BINS, FRAME_WIDTH / shr + 64, CV_32SC1);
+        integralBuffer.create(shrunk.rows, shrunk.cols, CV_32SC1);
+
+        hogluv.create((FRAME_HEIGHT / shr) * HOG_LUV_BINS + 1, FRAME_WIDTH / shr + 1, CV_32SC1);
+        hogluv.setTo(cv::Scalar::all(0));
+
         detCounter.create(1,1, CV_32SC1);
 
         octaves.upload(hoctaves);
@@ -432,16 +442,7 @@ private:
 
         GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
         cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-
-        fw /= shrinkage;
-        fh /= shrinkage;
-
-        for(int i = 0; i < Filds::HOG_LUV_BINS; ++i)
-        {
-            GpuMat channel(shrunk, cv::Rect(0, fh  * i, fw, fh ));
-            GpuMat sum(hogluv, cv::Rect(0, (fh + 1) * i, fw + 1, fh + 1));
-            cv::gpu::integralBuffered(channel, sum, integralBuffer);
-        }
+        device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, 0);
     }
 
 public:
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index fb936be88..1146b062b 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -271,6 +271,7 @@ GPU_TEST_P(SoftCascadeTestAll, detect,
     ASSERT_EQ(detections.cols / sizeof(Detection) ,3670U);
 }
 
+//ToDo: fix me
 GPU_TEST_P(SoftCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )

From 9b251f81309aad65344e3a345c87e132ff37e8d5 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 5 Nov 2012 14:21:46 +0400
Subject: [PATCH 055/155] remove Sobel normalization

---
 modules/gpu/src/softcascade.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 2d43a5440..1e0c271b9 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -396,8 +396,8 @@ private:
         GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
         GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
 
-        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, 3, 0.125f);
-        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, 3, 0.125f);
+        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0);
+        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1);
 
         GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
         GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
@@ -409,7 +409,7 @@ private:
         GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
         GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
 
-        cv::gpu::multiply(mag, cv::Scalar::all(1.f / ::log(2)), nmag);
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2))), nmag);
         cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
 
         //create uchar magnitude

From 27eb2e27db92c47d70c1e9d89187c2a28df93dc7 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 5 Nov 2012 18:52:35 +0400
Subject: [PATCH 056/155] enable fast  integral for Kepler

---
 modules/gpu/src/imgproc.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index df02213b1..0bf9c81c2 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -553,7 +553,7 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
 
     src.locateROI(whole, offset);
 
-    if (false && info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048)
+    if (info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048)
     {
         GpuMat srcAlligned;
 

From e6eb1b99e19b5e8e99e1d8aa872363335a6a0a92 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 10 Nov 2012 00:48:37 +0400
Subject: [PATCH 057/155] fix negative confidence bug

---
 modules/gpu/src/cuda/isf-sc.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 3391bb1a0..ee9a9f674 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -229,7 +229,7 @@ namespace icf {
             if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
         }
 
-        if(st == stEnd && !threadIdx.x)
+        if(!threadIdx.x && st == stEnd &&  ((confidence - FLT_EPSILON) >= 0))
         {
             int idx = atomicInc(ctr, ndetections);
             // store detection

From 40600fa5048ddf43bf8fc7602694ad723234c87d Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 10 Nov 2012 00:49:51 +0400
Subject: [PATCH 058/155] GPU version becomes algorithm

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  67 +++++-----
 modules/gpu/perf/perf_softcascade.cpp   | 146 +++++++++++----------
 modules/gpu/src/gpu_init.cpp            |  60 +++++++++
 modules/gpu/src/softcascade.cpp         | 161 +++++++++++++-----------
 modules/gpu/test/test_softcascade.cpp   | 147 +++++++++++++---------
 5 files changed, 346 insertions(+), 235 deletions(-)
 create mode 100644 modules/gpu/src/gpu_init.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 9b59c6004..4fc6179d8 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1534,10 +1534,12 @@ public:
 
 // ======================== GPU version for soft cascade ===================== //
 
-class CV_EXPORTS SoftCascade
+// Implementation of soft (stageless) cascaded detector.
+class CV_EXPORTS SCascade : public Algorithm
 {
 public:
 
+    // Representation of detectors result.
     struct CV_EXPORTS Detection
     {
         ushort x;
@@ -1549,47 +1551,44 @@ public:
 
         enum {PEDESTRIAN = 0};
     };
-    //! An empty cascade will be created.
-    SoftCascade();
 
-    //! Cascade will be created from file for scales from minScale to maxScale.
-    //! Param filename is a path to xml-serialized cascade.
-    //! Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
-    //! Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
-    SoftCascade( const string& filename, const float minScale = 0.4f, const float maxScale = 5.f);
+    // An empty cascade will be created.
+    // Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
+    // Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
+    // Param scales is a number of scales from minScale to maxScale.
+    // Param rejfactor is used for NMS.
+    SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55, const int rejfactor = 1);
 
-    //! cascade will be loaded from file "filename". The previous cascade will be destroyed.
-    //! Param filename is a path to xml-serialized cascade.
-    //! Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
-    //! Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
-    bool load( const string& filename, const float minScale = 0.4f, const float maxScale = 5.f);
+    virtual ~SCascade();
 
-    virtual ~SoftCascade();
+    cv::AlgorithmInfo* info() const;
 
-    //! detect specific objects on in the input frame for all scales computed flom minScale and maxscale values
-    //! Param image is input frame for detector. Cascade will be applied to it.
-    //! Param rois is a mask
-    //! Param objects 4-channel matrix thet contain detected rectangles
-    //! Param rejectfactor used for final object box computing
-    virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor = 1, int specificScale = -1) const;
+    // Load cascade from FileNode.
+    // Param fn is a root node for cascade. Should be <cascade>.
+    virtual bool load(const FileNode& fn);
 
-    //! detect specific objects on in the input frame for all scales computed flom minScale and maxscale values.
-    //! asynchronous version.
-    //! Param image is input frame for detector. Cascade will be applied to it.
-    //! Param rois is a mask
-    //! Param objects 4-channel matrix thet contain detected rectangles
-    //! Param rejectfactor used for final object box computing
-    //! Param ndet retrieves number of detections
-    //! Param stream wrapper for CUDA stream
-    virtual void detectMultiScale(const GpuMat& image, const GpuMat& rois, GpuMat& objects,
-    int rejectfactor, GpuMat& ndet, Stream stream) const;
+    // Load cascade config.
+    virtual void read(const FileNode& fn);
 
-    cv::Size getRoiSize() const;
+    // Return the vector of Decection objcts.
+    // Param image is a frame on which detector will be applied.
+    // Param rois is a vector of regions of interest. Only the objects that fall into one of the regions will be returned.
+    // Param objects is an output array of Detections
+    virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
+    virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
+
+    void genRoi(InputArray roi, OutputArray mask) const;
 
 private:
-    struct Filds;
-    Filds* filds;
+
+    struct Fields;
+    Fields* fields;
+
+    double minScale;
+    double maxScale;
+
+    int scales;
+    int rejfactor;
 };
 
 ////////////////////////////////// SURF //////////////////////////////////////////
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 9b53b2e84..1e62af8eb 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -25,8 +25,8 @@ void fixture##_##name::__cpu() { FAIL() << "No such CPU implementation analogy";
 namespace {
     struct DetectionLess
     {
-        bool operator()(const cv::gpu::SoftCascade::Detection& a,
-            const cv::gpu::SoftCascade::Detection& b) const
+        bool operator()(const cv::gpu::SCascade::Detection& a,
+            const cv::gpu::SCascade::Detection& b) const
         {
             if (a.x != b.x) return a.x < b.x;
             else if (a.y != b.y) return a.y < b.y;
@@ -51,7 +51,7 @@ namespace {
     {
         cv::Mat detections(objects);
 
-        typedef cv::gpu::SoftCascade::Detection Detection;
+        typedef cv::gpu::SCascade::Detection Detection;
         Detection* begin = (Detection*)(detections.ptr<char>(0));
         Detection* end = (Detection*)(detections.ptr<char>(0) + detections.cols);
         std::sort(begin, end, DetectionLess());
@@ -62,52 +62,54 @@ namespace {
 
 
 typedef std::tr1::tuple<std::string, std::string> fixture_t;
-typedef perf::TestBaseWithParam<fixture_t> SoftCascadeTest;
+typedef perf::TestBaseWithParam<fixture_t> SCascadeTest;
 
-GPU_PERF_TEST_P(SoftCascadeTest, detect,
+GPU_PERF_TEST_P(SCascadeTest, detect,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
 { }
 
-RUN_GPU(SoftCascadeTest, detect)
+RUN_GPU(SCascadeTest, detect)
 {
     cv::Mat cpu = readImage (GET_PARAM(1));
     ASSERT_FALSE(cpu.empty());
     cv::gpu::GpuMat colored(cpu);
 
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+    cv::gpu::SCascade cascade;
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SoftCascade::Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1), trois;
     rois.setTo(1);
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cv::gpu::GpuMat curr = objectBoxes;
-    cascade.detectMultiScale(colored, trois, curr);
+    cascade.detect(colored, trois, objectBoxes);
 
     TEST_CYCLE()
     {
-        curr = objectBoxes;
-        cascade.detectMultiScale(colored, trois, curr);
+        cascade.detect(colored, trois, objectBoxes);
     }
 
-    SANITY_CHECK(sortDetections(curr));
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SoftCascadeTest, detect)
+NO_CPU(SCascadeTest, detect)
 
-// RUN_CPU(SoftCascadeTest, detect)
+// RUN_CPU(SCascadeTest, detect)
 // {
 //     cv::Mat colored = readImage(GET_PARAM(1));
 //     ASSERT_FALSE(colored.empty());
 
-//     cv::SoftCascade cascade;
+//     cv::SCascade cascade;
 //     ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
 
 //     std::vector<cv::Rect> rois;
 
-//     typedef cv::SoftCascade::Detection Detection;
+//     typedef cv::SCascade::Detection Detection;
 //     std::vector<Detection>objects;
 //     cascade.detectMultiScale(colored, rois, objects);
 
@@ -124,42 +126,46 @@ static cv::Rect getFromTable(int idx)
 {
     static const cv::Rect rois[] =
     {
-        cv::Rect( 65,  20,  35, 80),
-        cv::Rect( 95,  35,  45, 40),
-        cv::Rect( 45,  35,  45, 40),
-        cv::Rect( 25,  27,  50, 45),
-        cv::Rect(100,  50,  45, 40),
+        cv::Rect( 65 * 4,  20 * 4,  35 * 4, 80 * 4),
+        cv::Rect( 95 * 4,  35 * 4,  45 * 4, 40 * 4),
+        cv::Rect( 45 * 4,  35 * 4,  45 * 4, 40 * 4),
+        cv::Rect( 25 * 4,  27 * 4,  50 * 4, 45 * 4),
+        cv::Rect(100 * 4,  50 * 4,  45 * 4, 40 * 4),
 
-        cv::Rect( 60,  30,  45, 40),
-        cv::Rect( 40,  55,  50, 40),
-        cv::Rect( 48,  37,  72, 80),
-        cv::Rect( 48,  32,  85, 58),
-        cv::Rect( 48,   0,  32, 27)
+        cv::Rect( 60 * 4,  30 * 4,  45 * 4, 40 * 4),
+        cv::Rect( 40 * 4,  55 * 4,  50 * 4, 40 * 4),
+        cv::Rect( 48 * 4,  37 * 4,  72 * 4, 80 * 4),
+        cv::Rect( 48 * 4,  32 * 4,  85 * 4, 58 * 4),
+        cv::Rect( 48 * 4,   0 * 4,  32 * 4, 27 * 4)
     };
 
     return rois[idx];
 }
 
 typedef std::tr1::tuple<std::string, std::string, int> roi_fixture_t;
-typedef perf::TestBaseWithParam<roi_fixture_t> SoftCascadeTestRoi;
+typedef perf::TestBaseWithParam<roi_fixture_t> SCascadeTestRoi;
 
-GPU_PERF_TEST_P(SoftCascadeTestRoi, detectInRoi,
+GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {}
 
-RUN_GPU(SoftCascadeTestRoi, detectInRoi)
+RUN_GPU(SCascadeTestRoi, detectInRoi)
 {
     cv::Mat cpu = readImage (GET_PARAM(1));
     ASSERT_FALSE(cpu.empty());
     cv::gpu::GpuMat colored(cpu);
 
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+    cv::gpu::SCascade cascade;
 
-    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(0);
 
     int nroi = GET_PARAM(2);
@@ -172,40 +178,42 @@ RUN_GPU(SoftCascadeTestRoi, detectInRoi)
     }
 
     cv::gpu::GpuMat trois;
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cv::gpu::GpuMat curr = objectBoxes;
-    cascade.detectMultiScale(colored, trois, curr);
+    cascade.detect(colored, trois, objectBoxes);
 
     TEST_CYCLE()
     {
-        curr = objectBoxes;
-        cascade.detectMultiScale(colored, trois, curr);
+        cascade.detect(colored, trois, objectBoxes);
     }
 
-    SANITY_CHECK(sortDetections(curr));
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SoftCascadeTestRoi, detectInRoi)
+NO_CPU(SCascadeTestRoi, detectInRoi)
 
 
-GPU_PERF_TEST_P(SoftCascadeTestRoi, detectEachRoi,
+GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 10)))
 {}
 
-RUN_GPU(SoftCascadeTestRoi, detectEachRoi)
+RUN_GPU(SCascadeTestRoi, detectEachRoi)
 {
     cv::Mat cpu = readImage (GET_PARAM(1));
     ASSERT_FALSE(cpu.empty());
     cv::gpu::GpuMat colored(cpu);
 
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+    cv::gpu::SCascade cascade;
 
-    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(0);
 
     int idx = GET_PARAM(2);
@@ -213,24 +221,22 @@ RUN_GPU(SoftCascadeTestRoi, detectEachRoi)
     cv::gpu::GpuMat sub(rois, r);
     sub.setTo(1);
 
-    cv::gpu::GpuMat curr = objectBoxes;
     cv::gpu::GpuMat trois;
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cascade.detectMultiScale(colored, trois, curr);
+    cascade.detect(colored, trois, objectBoxes);
 
     TEST_CYCLE()
     {
-        curr = objectBoxes;
-        cascade.detectMultiScale(colored, trois, curr);
+        cascade.detect(colored, trois, objectBoxes);
     }
 
-    SANITY_CHECK(sortDetections(curr));
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SoftCascadeTestRoi, detectEachRoi)
+NO_CPU(SCascadeTestRoi, detectEachRoi)
 
-GPU_PERF_TEST_P(SoftCascadeTest, detectOnIntegral,
+GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/integrals.xml"))))
@@ -243,37 +249,39 @@ GPU_PERF_TEST_P(SoftCascadeTest, detectOnIntegral,
         return std::string(s);
     }
 
-RUN_GPU(SoftCascadeTest, detectOnIntegral)
+RUN_GPU(SCascadeTest, detectOnIntegral)
 {
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
 
     cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
     for (int i = 0; i < 10; ++i)
     {
         cv::Mat channel;
-        fs[std::string("channel") + itoa(i)] >> channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
         cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
         gchannel.upload(channel);
     }
 
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(perf::TestBase::getDataPath(GET_PARAM(0))));
+    cv::gpu::SCascade cascade;
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SoftCascade::Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1), trois;
     rois.setTo(1);
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cv::gpu::GpuMat curr = objectBoxes;
-    cascade.detectMultiScale(hogluv, trois, curr);
+    cascade.detect(hogluv, trois, objectBoxes);
 
     TEST_CYCLE()
     {
-        curr = objectBoxes;
-        cascade.detectMultiScale(hogluv, trois, curr);
+        cascade.detect(hogluv, trois, objectBoxes);
     }
 
-    SANITY_CHECK(sortDetections(curr));
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SoftCascadeTest, detectOnIntegral)
\ No newline at end of file
+NO_CPU(SCascadeTest, detectOnIntegral)
\ No newline at end of file
diff --git a/modules/gpu/src/gpu_init.cpp b/modules/gpu/src/gpu_init.cpp
new file mode 100644
index 000000000..f25bc2ceb
--- /dev/null
+++ b/modules/gpu/src/gpu_init.cpp
@@ -0,0 +1,60 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2008-2012, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of the copyright holders may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include <precomp.hpp>
+
+namespace cv { namespace gpu
+{
+
+CV_INIT_ALGORITHM(SCascade, "CascadeDetector.SCascade",
+                  obj.info()->addParam(obj, "minScale",  obj.minScale);
+                  obj.info()->addParam(obj, "maxScale",  obj.maxScale);
+                  obj.info()->addParam(obj, "scales",    obj.scales);
+                  obj.info()->addParam(obj, "rejfactor", obj.rejfactor));
+
+bool initModule_gpu(void)
+{
+    Ptr<Algorithm> sc = createSCascade();
+    return sc->info() != 0;
+}
+
+} }
\ No newline at end of file
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 1e0c271b9..02481ed37 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -45,21 +45,18 @@
 
 #if !defined (HAVE_CUDA)
 
-cv::gpu::SoftCascade::SoftCascade() : filds(0) { throw_nogpu(); }
-cv::gpu::SoftCascade::SoftCascade( const string&, const float, const float) : filds(0) { throw_nogpu(); }
-cv::gpu::SoftCascade::~SoftCascade() { throw_nogpu(); }
-bool cv::gpu::SoftCascade::load( const string&, const float, const float) { throw_nogpu(); return false; }
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, const int, int) const
-{
-    throw_nogpu();
-}
+cv::gpu::SCascade::SCascade(const double, const double, const int, const int) { throw_nogpu(); }
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream) const
-{
-    throw_nogpu();
-}
+cv::gpu::SCascade::~SCascade() { throw_nogpu(); }
 
-cv::Size cv::gpu::SoftCascade::getRoiSize() const { throw_nogpu(); return cv::Size();}
+bool cv::gpu::SCascade::load(const FileNode&) { throw_nogpu(); return false;}
+
+void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, Stream&) const { throw_nogpu(); }
+void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, const int, Stream&) const { throw_nogpu(); }
+
+void cv::gpu::SCascade::genRoi(InputArray, OutputArray) const { throw_nogpu(); }
+
+void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 
 #else
 
@@ -92,7 +89,7 @@ namespace imgproc {
 
 }}}
 
-struct cv::gpu::SoftCascade::Filds
+struct cv::gpu::SCascade::Fields
 {
     struct CascadeIntrinsics
     {
@@ -126,7 +123,7 @@ struct cv::gpu::SoftCascade::Filds
         }
     };
 
-    static Filds* parseCascade(const FileNode &root, const float mins, const float maxs)
+    static Fields* parseCascade(const FileNode &root, const float mins, const float maxs)
     {
         static const char *const SC_STAGE_TYPE          = "stageType";
         static const char *const SC_BOOST               = "BOOST";
@@ -312,13 +309,13 @@ struct cv::gpu::SoftCascade::Filds
         cv::Mat hlevels(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );
         CV_Assert(!hlevels.empty());
 
-        Filds* filds = new Filds(mins, maxs, origWidth, origHeight, shrinkage, downscales,
+        Fields* fields = new Fields(mins, maxs, origWidth, origHeight, shrinkage, downscales,
             hoctaves, hstages, hnodes, hleaves, hlevels);
 
-        return filds;
+        return fields;
     }
 
-    Filds( const float mins, const float maxs, const int ow, const int oh, const int shr, const int ds,
+    Fields( const float mins, const float maxs, const int ow, const int oh, const int shr, const int ds,
         cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves, cv::Mat hlevels)
     : minScale(mins), maxScale(maxs), origObjWidth(ow), origObjHeight(oh), shrinkage(shr), downscales(ds)
     {
@@ -332,7 +329,7 @@ struct cv::gpu::SoftCascade::Filds
         hogluv.create((FRAME_HEIGHT / shr) * HOG_LUV_BINS + 1, FRAME_WIDTH / shr + 1, CV_32SC1);
         hogluv.setTo(cv::Scalar::all(0));
 
-        detCounter.create(1,1, CV_32SC1);
+        detCounter.create(sizeof(Detection) / sizeof(int),1, CV_32SC1);
 
         octaves.upload(hoctaves);
         stages.upload(hstages);
@@ -344,20 +341,21 @@ struct cv::gpu::SoftCascade::Filds
 
     }
 
-    void detect(int scale, const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, cudaStream_t stream) const
+    void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, cudaStream_t stream) const
     {
-        cudaMemset(detCounter.data, 0, detCounter.step * detCounter.rows * sizeof(int));
-        invoker(roi, hogluv, objects, detCounter, downscales, scale);
+        cudaMemset(count.data, 0, sizeof(Detection));
+        cudaSafeCall( cudaGetLastError());
+        invoker(roi, hogluv, objects, count, downscales, scale);
     }
 
     void preprocess(const cv::gpu::GpuMat& colored)
     {
         cudaMemset(plane.data, 0, plane.step * plane.rows);
 
-        static const int fw = Filds::FRAME_WIDTH;
-        static const int fh = Filds::FRAME_HEIGHT;
+        static const int fw = Fields::FRAME_WIDTH;
+        static const int fh = Fields::FRAME_HEIGHT;
 
-        GpuMat gray(plane, cv::Rect(0, fh * Filds::HOG_LUV_BINS, fw, fh));
+        GpuMat gray(plane, cv::Rect(0, fh * Fields::HOG_LUV_BINS, fw, fh));
         cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
         createHogBins(gray);
 
@@ -390,8 +388,8 @@ private:
 
     void createHogBins(const cv::gpu::GpuMat& gray)
     {
-        static const int fw = Filds::FRAME_WIDTH;
-        static const int fh = Filds::FRAME_HEIGHT;
+        static const int fw = Fields::FRAME_WIDTH;
+        static const int fh = Fields::FRAME_HEIGHT;
 
         GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
         GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
@@ -413,21 +411,21 @@ private:
         cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
 
         //create uchar magnitude
-        GpuMat cmag(plane, cv::Rect(0, fh * Filds::HOG_BINS, fw, fh));
+        GpuMat cmag(plane, cv::Rect(0, fh * Fields::HOG_BINS, fw, fh));
         nmag.convertTo(cmag, CV_8UC1);
 
-        device::icf::fillBins(plane, nang, fw, fh, Filds::HOG_BINS);
+        device::icf::fillBins(plane, nang, fw, fh, Fields::HOG_BINS);
     }
 
     void createLuvBins(const cv::gpu::GpuMat& colored)
     {
-        static const int fw = Filds::FRAME_WIDTH;
-        static const int fh = Filds::FRAME_HEIGHT;
+        static const int fw = Fields::FRAME_WIDTH;
+        static const int fh = Fields::FRAME_HEIGHT;
 
         cv::gpu::cvtColor(colored, luv, CV_BGR2Luv);
 
         std::vector<GpuMat> splited;
-        for(int i = 0; i < Filds::LUV_BINS; ++i)
+        for(int i = 0; i < Fields::LUV_BINS; ++i)
         {
             splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
         }
@@ -437,10 +435,10 @@ private:
 
     void integrate()
     {
-        int fw = Filds::FRAME_WIDTH;
-        int fh = Filds::FRAME_HEIGHT;
+        int fw = Fields::FRAME_WIDTH;
+        int fh = Fields::FRAME_HEIGHT;
 
-        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Filds::HOG_LUV_BINS));
+        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
         cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
         device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, 0);
     }
@@ -500,45 +498,33 @@ public:
     };
 };
 
-cv::gpu::SoftCascade::SoftCascade() : filds(0) {}
+cv::gpu::SCascade::SCascade(const double mins, const double maxs, const int sc, const int rjf)
+: fields(0),  minScale(mins), maxScale(maxs), scales(sc), rejfactor(rjf) {}
 
-cv::gpu::SoftCascade::SoftCascade( const string& filename, const float minScale, const float maxScale) : filds(0)
+cv::gpu::SCascade::~SCascade() { delete fields; }
+
+bool cv::gpu::SCascade::load(const FileNode& fn)
 {
-    load(filename, minScale, maxScale);
+    if (fields) delete fields;
+    fields = Fields::parseCascade(fn, minScale, maxScale);
+    return fields != 0;
 }
 
-cv::gpu::SoftCascade::~SoftCascade()
-{
-    delete filds;
-}
-
-bool cv::gpu::SoftCascade::load( const string& filename, const float minScale, const float maxScale)
-{
-    if (filds) delete filds;
-
-    cv::FileStorage fs(filename, FileStorage::READ);
-    if (!fs.isOpened()) return false;
-
-    filds = Filds::parseCascade(fs.getFirstTopLevelNode(), minScale, maxScale);
-    return filds != 0;
-}
-
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat& rois,
-                                GpuMat& objects, const int /*rejectfactor*/, int specificScale) const
+void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, Stream& s) const
 {
+    const GpuMat colored = image.getGpuMat();
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
     // we guess user knows about shrincage
-    CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
+    // CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
 
-
-    Filds& flds = *filds;
+    Fields& flds = *fields;
 
     if (colored.type() == CV_8UC3)
     {
         // only this window size allowed
-        CV_Assert(colored.cols == Filds::FRAME_WIDTH && colored.rows == Filds::FRAME_HEIGHT);
+        CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
         flds.preprocess(colored);
     }
     else
@@ -546,25 +532,60 @@ void cv::gpu::SoftCascade::detectMultiScale(const GpuMat& colored, const GpuMat&
         colored.copyTo(flds.hogluv);
     }
 
-    flds.detect(specificScale, rois, objects, 0);
+    GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
 
-    cv::Mat out(flds.detCounter);
-    int ndetections = *(out.ptr<int>(0));
+    GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
+    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
+    cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (! ndetections)
-        objects = GpuMat();
+    flds.detect(-1, rois, tmp, objects, stream);
+}
+
+void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, const int level, Stream& s) const
+{
+    const GpuMat colored = image.getGpuMat();
+    // only color images are supperted
+    CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
+
+    // we guess user knows about shrincage
+    // CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
+
+    Fields& flds = *fields;
+
+    if (colored.type() == CV_8UC3)
+    {
+        // only this window size allowed
+        CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
+        flds.preprocess(colored);
+    }
     else
-        objects = GpuMat(objects, cv::Rect(0, 0, ndetections * sizeof(Detection), 1));
+    {
+        colored.copyTo(flds.hogluv);
+    }
+
+    GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
+
+    GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
+    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    flds.detect(level, rois, tmp, objects, stream);
 }
 
-void cv::gpu::SoftCascade::detectMultiScale(const GpuMat&, const GpuMat&, GpuMat&, int, GpuMat&, Stream) const
+void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask) const
 {
-    // cudaStream_t stream = StreamAccessor::getStream(s);
+    const GpuMat roi = _roi.getGpuMat();
+    _mask.create( roi.cols / 4, roi.rows / 4, roi.type() );
+    GpuMat mask = _mask.getGpuMat();
+    cv::gpu::GpuMat tmp;
+
+    cv::gpu::resize(roi, tmp, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
+    cv::gpu::transpose(tmp, mask);
 }
 
-cv::Size cv::gpu::SoftCascade::getRoiSize() const
+void cv::gpu::SCascade::read(const FileNode& fn)
 {
-    return cv::Size(Filds::FRAME_WIDTH / (*filds).shrinkage, Filds::FRAME_HEIGHT / (*filds).shrinkage);
+    Algorithm::read(fn);
 }
 
 #endif
\ No newline at end of file
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 1146b062b..f26c44f0e 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -70,23 +70,23 @@ using cv::gpu::GpuMat;
 
 namespace {
 
-    typedef cv::gpu::SoftCascade::Detection Detection;
+    typedef cv::gpu::SCascade::Detection Detection;
 
     static cv::Rect getFromTable(int idx)
     {
         static const cv::Rect rois[] =
         {
-            cv::Rect( 65,  20,  35, 80),
-            cv::Rect( 95,  35,  45, 40),
-            cv::Rect( 45,  35,  45, 40),
-            cv::Rect( 25,  27,  50, 45),
-            cv::Rect(100,  50,  45, 40),
+            cv::Rect( 65 * 4,  20 * 4,  35 * 4, 80 * 4),
+            cv::Rect( 95 * 4,  35 * 4,  45 * 4, 40 * 4),
+            cv::Rect( 45 * 4,  35 * 4,  45 * 4, 40 * 4),
+            cv::Rect( 25 * 4,  27 * 4,  50 * 4, 45 * 4),
+            cv::Rect(100 * 4,  50 * 4,  45 * 4, 40 * 4),
 
-            cv::Rect( 60,  30,  45, 40),
-            cv::Rect( 40,  55,  50, 40),
-            cv::Rect( 48,  37,  72, 80),
-            cv::Rect( 48,  32,  85, 58),
-            cv::Rect( 48,   0,  32, 27)
+            cv::Rect( 60 * 4,  30 * 4,  45 * 4, 40 * 4),
+            cv::Rect( 40 * 4,  55 * 4,  50 * 4, 40 * 4),
+            cv::Rect( 48 * 4,  37 * 4,  72 * 4, 80 * 4),
+            cv::Rect( 48 * 4,  32 * 4,  85 * 4, 58 * 4),
+            cv::Rect( 48 * 4,   0 * 4,  32 * 4, 27 * 4)
         };
 
         return rois[idx];
@@ -140,11 +140,11 @@ namespace {
     }
 }
 
-typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SoftCascadeTestRoi;
-GPU_TEST_P(SoftCascadeTestRoi, detect,
+typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestRoi;
+GPU_TEST_P(SCascadeTestRoi, detect,
     testing::Combine(
         ALL_DEVICES,
-        testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
@@ -152,10 +152,14 @@ GPU_TEST_P(SoftCascadeTestRoi, detect,
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
     ASSERT_FALSE(coloredCpu.empty());
 
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(cvtest::TS::ptr()->get_data_path() + GET_PARAM(1)));
+    cv::gpu::SCascade cascade;
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1), trois;
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1), trois;
     rois.setTo(0);
 
     int nroi = GET_PARAM(3);
@@ -166,21 +170,21 @@ GPU_TEST_P(SoftCascadeTestRoi, detect,
         cv::Rect r = getFromTable(rng(10));
         GpuMat sub(rois, r);
         sub.setTo(1);
-        r.x *= 4; r.y *= 4; r.width *= 4; r.height *= 4;
         cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
     }
 
-    cv::gpu::transpose(rois, trois);
-
-    cascade.detectMultiScale(colored, trois, objectBoxes);
+    cascade.genRoi(rois, trois);
+    cascade.detect(colored, trois, objectBoxes);
 
     cv::Mat dt(objectBoxes);
-    typedef cv::gpu::SoftCascade::Detection Detection;
+    typedef cv::gpu::SCascade::Detection Detection;
 
-    Detection* dts = (Detection*)dt.data;
+    Detection* dts = ((Detection*)dt.data) + 1;
+    int* count = dt.ptr<int>(0);
 
-    printTotal(std::cout, dt.cols);
-    for (int i = 0; i  < (int)(dt.cols / sizeof(Detection)); ++i)
+    printTotal(std::cout, *count);
+
+    for (int i = 0; i  < *count; ++i)
     {
         Detection d = dts[i];
         print(std::cout, d);
@@ -188,43 +192,49 @@ GPU_TEST_P(SoftCascadeTestRoi, detect,
     }
 
     SHOW(result);
+
 }
 
-typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SoftCascadeTestLevel;
-GPU_TEST_P(SoftCascadeTestLevel, detect,
+typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestLevel;
+GPU_TEST_P(SCascadeTestLevel, detect,
         testing::Combine(
         ALL_DEVICES,
-        testing::Values(std::string("../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 47)
         ))
 {
     cv::gpu::setDevice(GET_PARAM(0).deviceID());
 
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + GET_PARAM(1);
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(xml));
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
     ASSERT_FALSE(coloredCpu.empty());
 
-    typedef cv::gpu::SoftCascade::Detection Detection;
-    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    typedef cv::gpu::SCascade::Detection Detection;
+    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(1);
 
     cv::gpu::GpuMat trois;
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
     int level = GET_PARAM(3);
-    cascade.detectMultiScale(colored, trois, objectBoxes, 1, level);
+    cascade.detect(colored, trois, objectBoxes, level);
 
     cv::Mat dt(objectBoxes);
 
-    Detection* dts = (Detection*)dt.data;
+    Detection* dts = ((Detection*)dt.data) + 1;
+    int* count = dt.ptr<int>(0);
+
     cv::Mat result(coloredCpu);
 
-    printTotal(std::cout, dt.cols);
-    for (int i = 0; i  < (int)(dt.cols / sizeof(Detection)); ++i)
+    printTotal(std::cout, *count);
+    for (int i = 0; i  < *count; ++i)
     {
         Detection d = dts[i];
         print(std::cout, d);
@@ -235,76 +245,89 @@ GPU_TEST_P(SoftCascadeTestLevel, detect,
     SHOW(result);
 }
 
-TEST(SoftCascadeTest, readCascade)
+TEST(SCascadeTest, readCascade)
 {
     std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(xml));
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 }
 
-typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SoftCascadeTestAll;
-GPU_TEST_P(SoftCascadeTestAll, detect,
+typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
+GPU_TEST_P(SCascadeTestAll, detect,
         ALL_DEVICES
         )
 {
     cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(xml));
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
         + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(0);
     GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
     sub.setTo(cv::Scalar::all(1));
 
     cv::gpu::GpuMat trois;
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cascade.detectMultiScale(colored, trois, objectBoxes);
+    cascade.detect(colored, trois, objectBoxes);
 
-    typedef cv::gpu::SoftCascade::Detection Detection;
+    typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
-    ASSERT_EQ(detections.cols / sizeof(Detection) ,3670U);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2460);
 }
 
-//ToDo: fix me
-GPU_TEST_P(SoftCascadeTestAll, detectOnIntegral,
+GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )
 {
     cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SoftCascade cascade;
-    ASSERT_TRUE(cascade.load(xml));
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
     std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
-    cv::FileStorage fs(intPath, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fsi(intPath, cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
 
     GpuMat hogluv(121 * 10, 161, CV_32SC1);
     for (int i = 0; i < 10; ++i)
     {
         cv::Mat channel;
-        fs[std::string("channel") + itoa(i)] >> channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
         GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
         gchannel.upload(channel);
     }
 
-    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cascade.getRoiSize(), CV_8UC1);
+    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
     rois.setTo(1);
 
     cv::gpu::GpuMat trois;
-    cv::gpu::transpose(rois, trois);
+    cascade.genRoi(rois, trois);
 
-    cascade.detectMultiScale(hogluv, trois, objectBoxes);
+    cascade.detect(hogluv, trois, objectBoxes);
 
-    typedef cv::gpu::SoftCascade::Detection Detection;
+    typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
 
-    ASSERT_EQ(detections.cols / sizeof(Detection) ,2042U);
+    ASSERT_EQ( a ,1024);
 }
 #endif
\ No newline at end of file

From 0cbf9eb22a264493da9ebf2e1101af60534cc12c Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 10 Nov 2012 03:59:09 +0400
Subject: [PATCH 059/155] add support for CUDA streams

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  2 +-
 modules/gpu/perf/perf_softcascade.cpp   | 42 ++++++++++++++-
 modules/gpu/src/cuda/integral_image.cu  |  1 -
 modules/gpu/src/cuda/isf-sc.cu          | 28 ++++++----
 modules/gpu/src/icf.hpp                 |  2 +-
 modules/gpu/src/softcascade.cpp         | 72 ++++++++++++++-----------
 modules/gpu/test/test_softcascade.cpp   | 39 ++++++++++++++
 7 files changed, 140 insertions(+), 46 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 4fc6179d8..8f327f227 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1577,7 +1577,7 @@ public:
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
 
-    void genRoi(InputArray roi, OutputArray mask) const;
+    void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
 
 private:
 
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 1e62af8eb..3e82cc5bb 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -284,4 +284,44 @@ RUN_GPU(SCascadeTest, detectOnIntegral)
     SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SCascadeTest, detectOnIntegral)
\ No newline at end of file
+NO_CPU(SCascadeTest, detectOnIntegral)
+
+GPU_PERF_TEST_P(SCascadeTest, detectStream,
+    testing::Combine(
+        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+        testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
+{ }
+
+RUN_GPU(SCascadeTest, detectStream)
+{
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1), trois;
+    rois.setTo(1);
+
+    cv::gpu::Stream s;
+
+    cascade.genRoi(rois, trois, s);
+
+    cascade.detect(colored, trois, objectBoxes, s);
+
+    TEST_CYCLE()
+    {
+        cascade.detect(colored, trois, objectBoxes, s);
+    }
+
+    cudaDeviceSynchronize();
+
+    SANITY_CHECK(sortDetections(objectBoxes));
+}
+
+NO_CPU(SCascadeTest, detectStream)
\ No newline at end of file
diff --git a/modules/gpu/src/cuda/integral_image.cu b/modules/gpu/src/cuda/integral_image.cu
index 5bd35bdc7..200960b43 100644
--- a/modules/gpu/src/cuda/integral_image.cu
+++ b/modules/gpu/src/cuda/integral_image.cu
@@ -444,7 +444,6 @@ namespace cv { namespace gpu { namespace device
         }
 
         // used for frame preprocessing before Soft Cascade evaluation: no synchronization needed
-        // ToDo: partial dy
         void shfl_integral_gpu_buffered(PtrStepSzb img, PtrStepSz<uint4> buffer, PtrStepSz<unsigned int> integral,
             int blockStep, cudaStream_t stream)
         {
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index ee9a9f674..0de2d8e37 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -71,7 +71,7 @@ namespace icf {
     }
 
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
-                  const int fw,  const int fh, const int bins)
+                  const int fw,  const int fh, const int bins, cudaStream_t stream )
     {
         const uchar* mag = (const uchar*)hogluv.ptr(fh * bins);
         uchar* hog = (uchar*)hogluv.ptr();
@@ -80,9 +80,12 @@ namespace icf {
         dim3 block(32, 8);
         dim3 grid(fw / 32, fh / 8);
 
-        magToHist<<<grid, block>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step, fh);
-        cudaSafeCall( cudaGetLastError() );
-        cudaSafeCall( cudaDeviceSynchronize() );
+        magToHist<<<grid, block, 0, stream>>>(mag, angle, nangle.step / sizeof(float), hog, hogluv.step, fh);
+        if (!stream)
+        {
+            cudaSafeCall( cudaGetLastError() );
+            cudaSafeCall( cudaDeviceSynchronize() );
+        }
     }
 
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
@@ -305,7 +308,7 @@ namespace icf {
 
     template<>
     void CascadeInvoker<CascadePolicy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale) const
+        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const
     {
         int fw = 160;
         int fh = 120;
@@ -325,22 +328,25 @@ namespace icf {
 
         if (scale == -1)
         {
-            test_kernel_warp<false><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, 0);
+            test_kernel_warp<false><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, 0);
             cudaSafeCall( cudaGetLastError());
 
             grid = dim3(fw, fh / 8, 47 - downscales);
-            test_kernel_warp<true><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, downscales);
+            test_kernel_warp<true><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, downscales);
         }
         else
         {
             if (scale >= downscales)
-                test_kernel_warp<true><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
+                test_kernel_warp<true><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
             else
-                test_kernel_warp<false><<<grid, block>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
+                test_kernel_warp<false><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
         }
 
-        cudaSafeCall( cudaGetLastError());
-        cudaSafeCall( cudaDeviceSynchronize());
+        if (!stream)
+        {
+            cudaSafeCall( cudaGetLastError());
+            cudaSafeCall( cudaDeviceSynchronize());
+        }
     }
 }
 }}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index d829012c8..60df55882 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -139,7 +139,7 @@ struct CascadeInvoker
     const float*  leaves;
 
     void operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales, const int csale = -1) const;
+        PtrStepSzi counter, const int downscales, const int csale = -1, const cudaStream_t& stream = 0) const;
 };
 
 }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 02481ed37..fdde2618e 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -54,7 +54,7 @@ bool cv::gpu::SCascade::load(const FileNode&) { throw_nogpu(); return false;}
 void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, Stream&) const { throw_nogpu(); }
 void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, const int, Stream&) const { throw_nogpu(); }
 
-void cv::gpu::SCascade::genRoi(InputArray, OutputArray) const { throw_nogpu(); }
+void cv::gpu::SCascade::genRoi(InputArray, OutputArray, Stream&) const { throw_nogpu(); }
 
 void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 
@@ -76,7 +76,7 @@ namespace cv { namespace gpu { namespace device {
 
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
-        const int fw, const int fh, const int bins);
+        const int fw, const int fh, const int bins, cudaStream_t stream);
 }
 
 namespace imgproc {
@@ -341,27 +341,30 @@ struct cv::gpu::SCascade::Fields
 
     }
 
-    void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, cudaStream_t stream) const
+    void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
     {
         cudaMemset(count.data, 0, sizeof(Detection));
         cudaSafeCall( cudaGetLastError());
-        invoker(roi, hogluv, objects, count, downscales, scale);
+        invoker(roi, hogluv, objects, count, downscales, scale, stream);
     }
 
-    void preprocess(const cv::gpu::GpuMat& colored)
+    void preprocess(const cv::gpu::GpuMat& colored, Stream& s)
     {
-        cudaMemset(plane.data, 0, plane.step * plane.rows);
+        if (s)
+            s.enqueueMemSet(plane, 0);
+        else
+            cudaMemset(plane.data, 0, plane.step * plane.rows);
 
         static const int fw = Fields::FRAME_WIDTH;
         static const int fh = Fields::FRAME_HEIGHT;
 
         GpuMat gray(plane, cv::Rect(0, fh * Fields::HOG_LUV_BINS, fw, fh));
-        cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY);
-        createHogBins(gray);
+        cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY, s);
+        createHogBins(gray ,s);
 
-        createLuvBins(colored);
+        createLuvBins(colored, s);
 
-        integrate();
+        integrate(s);
     }
 
 private:
@@ -386,7 +389,7 @@ private:
         return res;
     }
 
-    void createHogBins(const cv::gpu::GpuMat& gray)
+    void createHogBins(const cv::gpu::GpuMat& gray, Stream& s)
     {
         static const int fw = Fields::FRAME_WIDTH;
         static const int fh = Fields::FRAME_HEIGHT;
@@ -394,35 +397,38 @@ private:
         GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
         GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
 
-        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0);
-        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1);
+        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, sobelBuf, 3, 1, BORDER_DEFAULT, -1, s);
+        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, sobelBuf, 3, 1, BORDER_DEFAULT, -1, s);
 
         GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
         GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
 
-        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true);
+        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true, s);
 
         // normolize magnitude to uchar interval and angles to 6 bins
-
         GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
         GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
 
-        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2))), nmag);
-        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang);
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2))), nmag, 1, -1, s);
+        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang, 1, -1, s);
 
         //create uchar magnitude
         GpuMat cmag(plane, cv::Rect(0, fh * Fields::HOG_BINS, fw, fh));
-        nmag.convertTo(cmag, CV_8UC1);
+        if (s)
+            s.enqueueConvert(nmag, cmag, CV_8UC1);
+        else
+            nmag.convertTo(cmag, CV_8UC1);
 
-        device::icf::fillBins(plane, nang, fw, fh, Fields::HOG_BINS);
+        cudaStream_t stream = StreamAccessor::getStream(s);
+        device::icf::fillBins(plane, nang, fw, fh, Fields::HOG_BINS, stream);
     }
 
-    void createLuvBins(const cv::gpu::GpuMat& colored)
+    void createLuvBins(const cv::gpu::GpuMat& colored, Stream& s)
     {
         static const int fw = Fields::FRAME_WIDTH;
         static const int fh = Fields::FRAME_HEIGHT;
 
-        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv);
+        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv, s);
 
         std::vector<GpuMat> splited;
         for(int i = 0; i < Fields::LUV_BINS; ++i)
@@ -430,17 +436,18 @@ private:
             splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
         }
 
-        cv::gpu::split(luv, splited);
+        cv::gpu::split(luv, splited, s);
     }
 
-    void integrate()
+    void integrate( Stream& s)
     {
         int fw = Fields::FRAME_WIDTH;
         int fh = Fields::FRAME_HEIGHT;
 
         GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
-        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-        device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, 0);
+        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA, s);
+        cudaStream_t stream = StreamAccessor::getStream(s);
+        device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, stream);
     }
 
 public:
@@ -482,6 +489,8 @@ public:
     GpuMat leaves;
     GpuMat levels;
 
+    GpuMat sobelBuf;
+
     device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker;
 
     enum { BOOST = 0 };
@@ -516,6 +525,8 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
+    GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
+
     // we guess user knows about shrincage
     // CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
 
@@ -525,14 +536,13 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     {
         // only this window size allowed
         CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
-        flds.preprocess(colored);
+        flds.preprocess(colored, s);
     }
     else
     {
         colored.copyTo(flds.hogluv);
     }
 
-    GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
 
     GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
     objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
@@ -556,7 +566,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     {
         // only this window size allowed
         CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
-        flds.preprocess(colored);
+        flds.preprocess(colored, s);
     }
     else
     {
@@ -572,15 +582,15 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     flds.detect(level, rois, tmp, objects, stream);
 }
 
-void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask) const
+void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const
 {
     const GpuMat roi = _roi.getGpuMat();
     _mask.create( roi.cols / 4, roi.rows / 4, roi.type() );
     GpuMat mask = _mask.getGpuMat();
     cv::gpu::GpuMat tmp;
 
-    cv::gpu::resize(roi, tmp, cv::Size(), 0.25, 0.25, CV_INTER_AREA);
-    cv::gpu::transpose(tmp, mask);
+    cv::gpu::resize(roi, tmp, cv::Size(), 0.25, 0.25, CV_INTER_AREA, stream);
+    cv::gpu::transpose(tmp, mask, stream);
 }
 
 void cv::gpu::SCascade::read(const FileNode& fn)
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index f26c44f0e..cfae940c7 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -330,4 +330,43 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
 
     ASSERT_EQ( a ,1024);
 }
+
+GPU_TEST_P(SCascadeTestAll, detectStream,
+        ALL_DEVICES
+        )
+{
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
+
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
+
+    cv::gpu::Stream s;
+
+    cv::gpu::GpuMat trois;
+    cascade.genRoi(rois, trois, s);
+
+    cascade.detect(colored, trois, objectBoxes, s);
+
+    cudaDeviceSynchronize();
+
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2460);
+}
+
+
 #endif
\ No newline at end of file

From 916967cac5070d231195713f5a1057bd546c1d4d Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 10 Nov 2012 04:26:38 +0400
Subject: [PATCH 060/155] add comments to class declaration

---
 modules/gpu/include/opencv2/gpu/gpu.hpp | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 8f327f227..9a43760f9 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1570,13 +1570,22 @@ public:
     // Load cascade config.
     virtual void read(const FileNode& fn);
 
-    // Return the vector of Decection objcts.
+    // Return the matrix of of detectioned objects.
     // Param image is a frame on which detector will be applied.
-    // Param rois is a vector of regions of interest. Only the objects that fall into one of the regions will be returned.
-    // Param objects is an output array of Detections
+    // Param rois is a regions of interests mask generated by genRoi.
+    //    Only the objects that fall into one of the regions will be returned.
+    // Param objects is an output array of Detections represented as GpuMat of detections (SCascade::Detection)
+    //    The first element of the matrix is  actually a count of detections.
+    // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
+    // Param level used for execution cascade on specific scales pyramid level.
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
 
+    // Convert ROI matrix into the suitable for detect method.
+    // Param roi is an input matrix of the same size as the image.
+    //    There non zero value mean that detector should be executed in this point.
+    // Param mask is an output mask
+    // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
     void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
 
 private:

From d3ac282487793bc2a609ac1a58973dfa4e714864 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Sat, 10 Nov 2012 05:48:06 +0400
Subject: [PATCH 061/155] GPU soft cascade documentation

---
 modules/gpu/doc/object_detection.rst | 119 +++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)

diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst
index 133660236..64348717c 100644
--- a/modules/gpu/doc/object_detection.rst
+++ b/modules/gpu/doc/object_detection.rst
@@ -199,6 +199,125 @@ Returns block descriptors computed for the whole image.
 The function is mainly used to learn the classifier.
 
 
+Soft Cascade Classifier
+======================
+
+Soft Cascade Classifier for Object Detection
+----------------------------------------------------------
+
+Cascade detectors have been shown to operate extremely rapidly, with high accuracy, and have important applications in different spheres. The initial goal for this cascade implementation was the fast and accurate pedestrian detector but it also useful in general. Soft cascade is trained with AdaBoost. But instead of training sequence of stages, the soft cascade is trained as a one long stage of T weak classifiers. Soft cascade is formulated as follows:
+
+.. math::
+    \texttt{H}(x) = \sum _{\texttt{t}=1..\texttt{T}} {\texttt{s}_t(x)}
+
+where :math:`\texttt{s}_t(x) = \alpha_t\texttt{h}_t(x)` are the set of thresholded weak classifiers selected during AdaBoost training scaled by the associated weights. Let
+
+.. math::
+    \texttt{H}_t(x) = \sum _{\texttt{i}=1..\texttt{t}} {\texttt{s}_i(x)}
+
+be the partial sum of sample responses before :math:`t`-the weak classifier will be applied. The funtcion :math:`\texttt{H}_t(x)` of :math:`t` for sample :math:`x` named *sample trace*.
+After each weak classifier evaluation, the sample trace at the point :math:`t` is compared with the rejection threshold :math:`r_t`. The sequence of :math:`r_t` named *rejection trace*.
+
+The sample has been rejected if it fall rejection threshold. So stageless cascade allows to reject not-object sample as soon as possible. Another meaning of the sample trace is a confidence with that sample recognized as desired object. At each :math:`t` that confidence depend on all previous weak classifier. This feature of soft cascade is resulted in more accurate detection. The original formulation of soft cascade can be found in [BJ05]_.
+
+.. [BJ05] Lubomir Bourdev and Jonathan Brandt. tRobust Object Detection Via Soft Cascade. IEEE CVPR, 2005.
+.. [BMTG12] Rodrigo Benenson, Markus Mathias, Radu Timofte and Luc Van Gool. Pedestrian detection at 100 frames per second. IEEE CVPR, 2012.
+
+
+SCascade
+----------------
+.. ocv:class:: SCascade
+
+Implementation of soft (stageless) cascaded detector. ::
+
+    class CV_EXPORTS SCascade : public Algorithm
+    {
+        struct CV_EXPORTS Detection
+        {
+              ushort x;
+              ushort y;
+              ushort w;
+              ushort h;
+              float confidence;
+              int kind;
+
+              enum {PEDESTRIAN = 0};
+        };
+
+        SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55, const int rejfactor = 1);
+        virtual ~SCascade();
+        virtual bool load(const FileNode& fn);
+        virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
+        virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
+        void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
+    };
+
+
+SCascade::SCascade
+--------------------------
+An empty cascade will be created.
+
+.. ocv:function:: bool SCascade::SCascade(const float minScale = 0.4f, const float maxScale = 5.f, const int scales = 55, const int rejfactor = 1)
+
+    :param minScale: a minimum scale relative to the original size of the image on which cascade will be applyed.
+
+    :param maxScale: a maximum scale relative to the original size of the image on which cascade will be applyed.
+
+    :param scales: a number of scales from minScale to maxScale.
+
+    :param rejfactor: used for non maximum suppression.
+
+
+
+SCascade::~SCascade
+---------------------------
+Destructor for SCascade.
+
+.. ocv:function:: SCascade::~SCascade()
+
+
+
+SCascade::load
+--------------------------
+Load cascade from FileNode.
+
+.. ocv:function:: bool SCascade::load(const FileNode& fn)
+
+    :param fn: File node from which the soft cascade are read.
+
+
+
+SCascade::detect
+--------------------------
+Apply cascade to an input frame and return the vector of Decection objcts.
+
+.. ocv:function:: void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const
+.. ocv:function:: void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const
+
+    :param image: a frame on which detector will be applied.
+
+    :param rois: a regions of interests mask generated by genRoi. Only the objects that fall into one of the regions will be returned.
+
+    :param objects: an output array of Detections represented as GpuMat of detections (SCascade::Detection). The first element of the matrix is  actually a count of detections.
+
+    :param stream: a high-level CUDA stream abstraction used for asynchronous execution.
+
+    :param level: used for execution cascade on specific scales pyramid level.
+
+
+SCascade::genRoi
+--------------------------
+Convert ROI matrix into the suitable for detect method.
+
+.. ocv:function:: void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const
+
+    :param rois: an input matrix of the same size as the image. There non zero value mean that detector should be executed in this point.
+
+    :param mask: an output mask
+
+    :param stream: a high-level CUDA stream abstraction used for asynchronous execution.
+
+
 
 gpu::CascadeClassifier_GPU
 --------------------------

From 29f89e8930c91c1e9fdcccb31d34acb1552b9281 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 30 Oct 2012 12:14:07 +0400
Subject: [PATCH 062/155] moved block.hpp to include folder

---
 modules/gpu/{src => include}/opencv2/gpu/device/block.hpp | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename modules/gpu/{src => include}/opencv2/gpu/device/block.hpp (100%)

diff --git a/modules/gpu/src/opencv2/gpu/device/block.hpp b/modules/gpu/include/opencv2/gpu/device/block.hpp
similarity index 100%
rename from modules/gpu/src/opencv2/gpu/device/block.hpp
rename to modules/gpu/include/opencv2/gpu/device/block.hpp

From 810829f32ee604433cf99cbc679139e20407f938 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 9 Nov 2012 13:14:59 +0400
Subject: [PATCH 063/155] speedup compilation of row_filter.cu and
 column_filter.cu

split them into several small files
---
 modules/gpu/src/cuda/column_filter.0.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.1.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.2.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.3.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.4.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.5.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.6.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.7.cu |  53 ++++
 modules/gpu/src/cuda/column_filter.cu   | 391 ------------------------
 modules/gpu/src/cuda/column_filter.h    | 378 +++++++++++++++++++++++
 modules/gpu/src/cuda/row_filter.0.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.1.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.2.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.3.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.4.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.5.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.6.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.7.cu    |  53 ++++
 modules/gpu/src/cuda/row_filter.cu      | 390 -----------------------
 modules/gpu/src/cuda/row_filter.h       | 377 +++++++++++++++++++++++
 modules/gpu/src/filtering.cpp           |  54 ++--
 21 files changed, 1625 insertions(+), 813 deletions(-)
 create mode 100644 modules/gpu/src/cuda/column_filter.0.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.1.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.2.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.3.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.4.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.5.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.6.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.7.cu
 delete mode 100644 modules/gpu/src/cuda/column_filter.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.h
 create mode 100644 modules/gpu/src/cuda/row_filter.0.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.1.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.2.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.3.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.4.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.5.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.6.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.7.cu
 delete mode 100644 modules/gpu/src/cuda/row_filter.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.h

diff --git a/modules/gpu/src/cuda/column_filter.0.cu b/modules/gpu/src/cuda/column_filter.0.cu
new file mode 100644
index 000000000..c35c6ee64
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.0.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float, uchar>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.1.cu b/modules/gpu/src/cuda/column_filter.1.cu
new file mode 100644
index 000000000..9a2d6a042
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.1.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float3, uchar3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.2.cu b/modules/gpu/src/cuda/column_filter.2.cu
new file mode 100644
index 000000000..05ee01c76
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.2.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float4, uchar4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.3.cu b/modules/gpu/src/cuda/column_filter.3.cu
new file mode 100644
index 000000000..1bf49219f
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.3.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float3, short3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.4.cu b/modules/gpu/src/cuda/column_filter.4.cu
new file mode 100644
index 000000000..bec7a085a
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.4.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float, int>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.5.cu b/modules/gpu/src/cuda/column_filter.5.cu
new file mode 100644
index 000000000..8194ee39a
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.5.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.6.cu b/modules/gpu/src/cuda/column_filter.6.cu
new file mode 100644
index 000000000..d8fc49be6
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.6.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.7.cu b/modules/gpu/src/cuda/column_filter.7.cu
new file mode 100644
index 000000000..534bd821e
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.7.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.cu b/modules/gpu/src/cuda/column_filter.cu
deleted file mode 100644
index af7369ad5..000000000
--- a/modules/gpu/src/cuda/column_filter.cu
+++ /dev/null
@@ -1,391 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#if !defined CUDA_DISABLER
-
-#include "internal_shared.hpp"
-#include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vec_math.hpp"
-#include "opencv2/gpu/device/limits.hpp"
-#include "opencv2/gpu/device/border_interpolate.hpp"
-#include "opencv2/gpu/device/static_check.hpp"
-
-namespace cv { namespace gpu { namespace device
-{
-    namespace column_filter
-    {
-        #define MAX_KERNEL_SIZE 32
-
-        __constant__ float c_kernel[MAX_KERNEL_SIZE];
-
-        void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
-        {
-            if (stream == 0)
-                cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
-            else
-                cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
-        }
-
-        template <int KSIZE, typename T, typename D, typename B>
-        __global__ void linearColumnFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
-        {
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 200)
-                const int BLOCK_DIM_X = 16;
-                const int BLOCK_DIM_Y = 16;
-                const int PATCH_PER_BLOCK = 4;
-                const int HALO_SIZE = KSIZE <= 16 ? 1 : 2;
-            #else
-                const int BLOCK_DIM_X = 16;
-                const int BLOCK_DIM_Y = 8;
-                const int PATCH_PER_BLOCK = 2;
-                const int HALO_SIZE = 2;
-            #endif
-
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
-
-            __shared__ sum_t smem[(PATCH_PER_BLOCK + 2 * HALO_SIZE) * BLOCK_DIM_Y][BLOCK_DIM_X];
-
-            const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
-
-            if (x >= src.cols)
-                return;
-
-            const T* src_col = src.ptr() + x;
-
-            const int yStart = blockIdx.y * (BLOCK_DIM_Y * PATCH_PER_BLOCK) + threadIdx.y;
-
-            if (blockIdx.y > 0)
-            {
-                //Upper halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart - (HALO_SIZE - j) * BLOCK_DIM_Y, x));
-            }
-            else
-            {
-                //Upper halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_low(yStart - (HALO_SIZE - j) * BLOCK_DIM_Y, src_col, src.step));
-            }
-
-            if (blockIdx.y + 2 < gridDim.y)
-            {
-                //Main data
-                #pragma unroll
-                for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-                    smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart + j * BLOCK_DIM_Y, x));
-
-                //Lower halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_Y, x));
-            }
-            else
-            {
-                //Main data
-                #pragma unroll
-                for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-                    smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_high(yStart + j * BLOCK_DIM_Y, src_col, src.step));
-
-                //Lower halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_high(yStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_Y, src_col, src.step));
-            }
-
-            __syncthreads();
-
-            #pragma unroll
-            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-            {
-                const int y = yStart + j * BLOCK_DIM_Y;
-
-                if (y < src.rows)
-                {
-                    sum_t sum = VecTraits<sum_t>::all(0);
-
-                    #pragma unroll
-                    for (int k = 0; k < KSIZE; ++k)
-                        sum = sum + smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y - anchor + k][threadIdx.x] * c_kernel[k];
-
-                    dst(y, x) = saturate_cast<D>(sum);
-                }
-            }
-        }
-
-        template <int KSIZE, typename T, typename D, template<typename> class B>
-        void linearColumnFilter_caller(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream)
-        {
-            int BLOCK_DIM_X;
-            int BLOCK_DIM_Y;
-            int PATCH_PER_BLOCK;
-
-            if (cc >= 20)
-            {
-                BLOCK_DIM_X = 16;
-                BLOCK_DIM_Y = 16;
-                PATCH_PER_BLOCK = 4;
-            }
-            else
-            {
-                BLOCK_DIM_X = 16;
-                BLOCK_DIM_Y = 8;
-                PATCH_PER_BLOCK = 2;
-            }
-
-            const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-            const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y * PATCH_PER_BLOCK));
-
-            B<T> brd(src.rows);
-
-            linearColumnFilter<KSIZE, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, brd);
-
-            cudaSafeCall( cudaGetLastError() );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-
-        template <typename T, typename D>
-        void linearColumnFilter_gpu(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream)
-        {
-            typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream);
-
-            static const caller_t callers[5][33] =
-            {
-                {
-                    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>,
-                    linearColumnFilter_caller<17, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<18, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<19, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<20, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<21, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<22, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<23, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<24, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<25, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<26, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<27, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<28, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<29, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<30, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<31, T, D, BrdColReflect101>,
-                    linearColumnFilter_caller<32, 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>,
-                    linearColumnFilter_caller<17, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<18, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<19, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<20, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<21, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<22, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<23, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<24, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<25, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<26, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<27, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<28, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<29, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<30, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<31, T, D, BrdColReplicate>,
-                    linearColumnFilter_caller<32, 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>,
-                    linearColumnFilter_caller<17, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<18, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<19, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<20, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<21, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<22, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<23, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<24, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<25, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<26, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<27, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<28, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<29, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<30, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<31, T, D, BrdColConstant>,
-                    linearColumnFilter_caller<32, 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>,
-                    linearColumnFilter_caller<17, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<18, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<19, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<20, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<21, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<22, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<23, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<24, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<25, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<26, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<27, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<28, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<29, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<30, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<31, T, D, BrdColReflect>,
-                    linearColumnFilter_caller<32, 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>,
-                    linearColumnFilter_caller<17, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<18, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<19, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<20, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<21, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<22, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<23, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<24, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<25, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<26, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<27, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<28, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<29, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<30, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<31, T, D, BrdColWrap>,
-                    linearColumnFilter_caller<32, T, D, BrdColWrap>
-                }
-            };
-
-            loadKernel(kernel, ksize, stream);
-
-            callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
-        }
-
-        template void linearColumnFilter_gpu<float , uchar >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float3, uchar3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float4, uchar4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float3, short3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float , int   >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float , float >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearColumnFilter_gpu<float4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-    } // namespace column_filter
-}}} // namespace cv { namespace gpu { namespace device
-
-
-#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.h b/modules/gpu/src/cuda/column_filter.h
new file mode 100644
index 000000000..dbcd09fa3
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.h
@@ -0,0 +1,378 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
+#include "opencv2/gpu/device/border_interpolate.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
+{
+    #define MAX_KERNEL_SIZE 32
+
+    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+    void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
+    {
+        if (stream == 0)
+            cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
+    }
+
+    template <int KSIZE, typename T, typename D, typename B>
+    __global__ void linearColumnFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
+    {
+        #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 200)
+            const int BLOCK_DIM_X = 16;
+            const int BLOCK_DIM_Y = 16;
+            const int PATCH_PER_BLOCK = 4;
+            const int HALO_SIZE = KSIZE <= 16 ? 1 : 2;
+        #else
+            const int BLOCK_DIM_X = 16;
+            const int BLOCK_DIM_Y = 8;
+            const int PATCH_PER_BLOCK = 2;
+            const int HALO_SIZE = 2;
+        #endif
+
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+
+        __shared__ sum_t smem[(PATCH_PER_BLOCK + 2 * HALO_SIZE) * BLOCK_DIM_Y][BLOCK_DIM_X];
+
+        const int x = blockIdx.x * BLOCK_DIM_X + threadIdx.x;
+
+        if (x >= src.cols)
+            return;
+
+        const T* src_col = src.ptr() + x;
+
+        const int yStart = blockIdx.y * (BLOCK_DIM_Y * PATCH_PER_BLOCK) + threadIdx.y;
+
+        if (blockIdx.y > 0)
+        {
+            //Upper halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart - (HALO_SIZE - j) * BLOCK_DIM_Y, x));
+        }
+        else
+        {
+            //Upper halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_low(yStart - (HALO_SIZE - j) * BLOCK_DIM_Y, src_col, src.step));
+        }
+
+        if (blockIdx.y + 2 < gridDim.y)
+        {
+            //Main data
+            #pragma unroll
+            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+                smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart + j * BLOCK_DIM_Y, x));
+
+            //Lower halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(src(yStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_Y, x));
+        }
+        else
+        {
+            //Main data
+            #pragma unroll
+            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+                smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_high(yStart + j * BLOCK_DIM_Y, src_col, src.step));
+
+            //Lower halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_Y + j * BLOCK_DIM_Y][threadIdx.x] = saturate_cast<sum_t>(brd.at_high(yStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_Y, src_col, src.step));
+        }
+
+        __syncthreads();
+
+        #pragma unroll
+        for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+        {
+            const int y = yStart + j * BLOCK_DIM_Y;
+
+            if (y < src.rows)
+            {
+                sum_t sum = VecTraits<sum_t>::all(0);
+
+                #pragma unroll
+                for (int k = 0; k < KSIZE; ++k)
+                    sum = sum + smem[threadIdx.y + HALO_SIZE * BLOCK_DIM_Y + j * BLOCK_DIM_Y - anchor + k][threadIdx.x] * c_kernel[k];
+
+                dst(y, x) = saturate_cast<D>(sum);
+            }
+        }
+    }
+
+    template <int KSIZE, typename T, typename D, template<typename> class B>
+    void caller(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream)
+    {
+        int BLOCK_DIM_X;
+        int BLOCK_DIM_Y;
+        int PATCH_PER_BLOCK;
+
+        if (cc >= 20)
+        {
+            BLOCK_DIM_X = 16;
+            BLOCK_DIM_Y = 16;
+            PATCH_PER_BLOCK = 4;
+        }
+        else
+        {
+            BLOCK_DIM_X = 16;
+            BLOCK_DIM_Y = 8;
+            PATCH_PER_BLOCK = 2;
+        }
+
+        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+        const dim3 grid(divUp(src.cols, BLOCK_DIM_X), divUp(src.rows, BLOCK_DIM_Y * PATCH_PER_BLOCK));
+
+        B<T> brd(src.rows);
+
+        linearColumnFilter<KSIZE, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, brd);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+namespace filter
+{
+    template <typename T, typename D>
+    void linearColumn(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream)
+    {
+        typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream);
+
+        static const caller_t callers[5][33] =
+        {
+            {
+                0,
+                ::caller< 1, T, D, BrdColReflect101>,
+                ::caller< 2, T, D, BrdColReflect101>,
+                ::caller< 3, T, D, BrdColReflect101>,
+                ::caller< 4, T, D, BrdColReflect101>,
+                ::caller< 5, T, D, BrdColReflect101>,
+                ::caller< 6, T, D, BrdColReflect101>,
+                ::caller< 7, T, D, BrdColReflect101>,
+                ::caller< 8, T, D, BrdColReflect101>,
+                ::caller< 9, T, D, BrdColReflect101>,
+                ::caller<10, T, D, BrdColReflect101>,
+                ::caller<11, T, D, BrdColReflect101>,
+                ::caller<12, T, D, BrdColReflect101>,
+                ::caller<13, T, D, BrdColReflect101>,
+                ::caller<14, T, D, BrdColReflect101>,
+                ::caller<15, T, D, BrdColReflect101>,
+                ::caller<16, T, D, BrdColReflect101>,
+                ::caller<17, T, D, BrdColReflect101>,
+                ::caller<18, T, D, BrdColReflect101>,
+                ::caller<19, T, D, BrdColReflect101>,
+                ::caller<20, T, D, BrdColReflect101>,
+                ::caller<21, T, D, BrdColReflect101>,
+                ::caller<22, T, D, BrdColReflect101>,
+                ::caller<23, T, D, BrdColReflect101>,
+                ::caller<24, T, D, BrdColReflect101>,
+                ::caller<25, T, D, BrdColReflect101>,
+                ::caller<26, T, D, BrdColReflect101>,
+                ::caller<27, T, D, BrdColReflect101>,
+                ::caller<28, T, D, BrdColReflect101>,
+                ::caller<29, T, D, BrdColReflect101>,
+                ::caller<30, T, D, BrdColReflect101>,
+                ::caller<31, T, D, BrdColReflect101>,
+                ::caller<32, T, D, BrdColReflect101>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdColReplicate>,
+                ::caller< 2, T, D, BrdColReplicate>,
+                ::caller< 3, T, D, BrdColReplicate>,
+                ::caller< 4, T, D, BrdColReplicate>,
+                ::caller< 5, T, D, BrdColReplicate>,
+                ::caller< 6, T, D, BrdColReplicate>,
+                ::caller< 7, T, D, BrdColReplicate>,
+                ::caller< 8, T, D, BrdColReplicate>,
+                ::caller< 9, T, D, BrdColReplicate>,
+                ::caller<10, T, D, BrdColReplicate>,
+                ::caller<11, T, D, BrdColReplicate>,
+                ::caller<12, T, D, BrdColReplicate>,
+                ::caller<13, T, D, BrdColReplicate>,
+                ::caller<14, T, D, BrdColReplicate>,
+                ::caller<15, T, D, BrdColReplicate>,
+                ::caller<16, T, D, BrdColReplicate>,
+                ::caller<17, T, D, BrdColReplicate>,
+                ::caller<18, T, D, BrdColReplicate>,
+                ::caller<19, T, D, BrdColReplicate>,
+                ::caller<20, T, D, BrdColReplicate>,
+                ::caller<21, T, D, BrdColReplicate>,
+                ::caller<22, T, D, BrdColReplicate>,
+                ::caller<23, T, D, BrdColReplicate>,
+                ::caller<24, T, D, BrdColReplicate>,
+                ::caller<25, T, D, BrdColReplicate>,
+                ::caller<26, T, D, BrdColReplicate>,
+                ::caller<27, T, D, BrdColReplicate>,
+                ::caller<28, T, D, BrdColReplicate>,
+                ::caller<29, T, D, BrdColReplicate>,
+                ::caller<30, T, D, BrdColReplicate>,
+                ::caller<31, T, D, BrdColReplicate>,
+                ::caller<32, T, D, BrdColReplicate>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdColConstant>,
+                ::caller< 2, T, D, BrdColConstant>,
+                ::caller< 3, T, D, BrdColConstant>,
+                ::caller< 4, T, D, BrdColConstant>,
+                ::caller< 5, T, D, BrdColConstant>,
+                ::caller< 6, T, D, BrdColConstant>,
+                ::caller< 7, T, D, BrdColConstant>,
+                ::caller< 8, T, D, BrdColConstant>,
+                ::caller< 9, T, D, BrdColConstant>,
+                ::caller<10, T, D, BrdColConstant>,
+                ::caller<11, T, D, BrdColConstant>,
+                ::caller<12, T, D, BrdColConstant>,
+                ::caller<13, T, D, BrdColConstant>,
+                ::caller<14, T, D, BrdColConstant>,
+                ::caller<15, T, D, BrdColConstant>,
+                ::caller<16, T, D, BrdColConstant>,
+                ::caller<17, T, D, BrdColConstant>,
+                ::caller<18, T, D, BrdColConstant>,
+                ::caller<19, T, D, BrdColConstant>,
+                ::caller<20, T, D, BrdColConstant>,
+                ::caller<21, T, D, BrdColConstant>,
+                ::caller<22, T, D, BrdColConstant>,
+                ::caller<23, T, D, BrdColConstant>,
+                ::caller<24, T, D, BrdColConstant>,
+                ::caller<25, T, D, BrdColConstant>,
+                ::caller<26, T, D, BrdColConstant>,
+                ::caller<27, T, D, BrdColConstant>,
+                ::caller<28, T, D, BrdColConstant>,
+                ::caller<29, T, D, BrdColConstant>,
+                ::caller<30, T, D, BrdColConstant>,
+                ::caller<31, T, D, BrdColConstant>,
+                ::caller<32, T, D, BrdColConstant>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdColReflect>,
+                ::caller< 2, T, D, BrdColReflect>,
+                ::caller< 3, T, D, BrdColReflect>,
+                ::caller< 4, T, D, BrdColReflect>,
+                ::caller< 5, T, D, BrdColReflect>,
+                ::caller< 6, T, D, BrdColReflect>,
+                ::caller< 7, T, D, BrdColReflect>,
+                ::caller< 8, T, D, BrdColReflect>,
+                ::caller< 9, T, D, BrdColReflect>,
+                ::caller<10, T, D, BrdColReflect>,
+                ::caller<11, T, D, BrdColReflect>,
+                ::caller<12, T, D, BrdColReflect>,
+                ::caller<13, T, D, BrdColReflect>,
+                ::caller<14, T, D, BrdColReflect>,
+                ::caller<15, T, D, BrdColReflect>,
+                ::caller<16, T, D, BrdColReflect>,
+                ::caller<17, T, D, BrdColReflect>,
+                ::caller<18, T, D, BrdColReflect>,
+                ::caller<19, T, D, BrdColReflect>,
+                ::caller<20, T, D, BrdColReflect>,
+                ::caller<21, T, D, BrdColReflect>,
+                ::caller<22, T, D, BrdColReflect>,
+                ::caller<23, T, D, BrdColReflect>,
+                ::caller<24, T, D, BrdColReflect>,
+                ::caller<25, T, D, BrdColReflect>,
+                ::caller<26, T, D, BrdColReflect>,
+                ::caller<27, T, D, BrdColReflect>,
+                ::caller<28, T, D, BrdColReflect>,
+                ::caller<29, T, D, BrdColReflect>,
+                ::caller<30, T, D, BrdColReflect>,
+                ::caller<31, T, D, BrdColReflect>,
+                ::caller<32, T, D, BrdColReflect>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdColWrap>,
+                ::caller< 2, T, D, BrdColWrap>,
+                ::caller< 3, T, D, BrdColWrap>,
+                ::caller< 4, T, D, BrdColWrap>,
+                ::caller< 5, T, D, BrdColWrap>,
+                ::caller< 6, T, D, BrdColWrap>,
+                ::caller< 7, T, D, BrdColWrap>,
+                ::caller< 8, T, D, BrdColWrap>,
+                ::caller< 9, T, D, BrdColWrap>,
+                ::caller<10, T, D, BrdColWrap>,
+                ::caller<11, T, D, BrdColWrap>,
+                ::caller<12, T, D, BrdColWrap>,
+                ::caller<13, T, D, BrdColWrap>,
+                ::caller<14, T, D, BrdColWrap>,
+                ::caller<15, T, D, BrdColWrap>,
+                ::caller<16, T, D, BrdColWrap>,
+                ::caller<17, T, D, BrdColWrap>,
+                ::caller<18, T, D, BrdColWrap>,
+                ::caller<19, T, D, BrdColWrap>,
+                ::caller<20, T, D, BrdColWrap>,
+                ::caller<21, T, D, BrdColWrap>,
+                ::caller<22, T, D, BrdColWrap>,
+                ::caller<23, T, D, BrdColWrap>,
+                ::caller<24, T, D, BrdColWrap>,
+                ::caller<25, T, D, BrdColWrap>,
+                ::caller<26, T, D, BrdColWrap>,
+                ::caller<27, T, D, BrdColWrap>,
+                ::caller<28, T, D, BrdColWrap>,
+                ::caller<29, T, D, BrdColWrap>,
+                ::caller<30, T, D, BrdColWrap>,
+                ::caller<31, T, D, BrdColWrap>,
+                ::caller<32, T, D, BrdColWrap>
+            }
+        };
+
+        ::loadKernel(kernel, ksize, stream);
+
+        callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
+    }
+}
diff --git a/modules/gpu/src/cuda/row_filter.0.cu b/modules/gpu/src/cuda/row_filter.0.cu
new file mode 100644
index 000000000..a1a8f36ca
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.0.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<uchar, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.1.cu b/modules/gpu/src/cuda/row_filter.1.cu
new file mode 100644
index 000000000..ab2248e1b
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.1.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<uchar3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.2.cu b/modules/gpu/src/cuda/row_filter.2.cu
new file mode 100644
index 000000000..5aa2e2b80
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.2.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<uchar4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.3.cu b/modules/gpu/src/cuda/row_filter.3.cu
new file mode 100644
index 000000000..9d131a959
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.3.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<short3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.4.cu b/modules/gpu/src/cuda/row_filter.4.cu
new file mode 100644
index 000000000..0aae534ce
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.4.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<int, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.5.cu b/modules/gpu/src/cuda/row_filter.5.cu
new file mode 100644
index 000000000..dd1f2be13
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.5.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<float, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.6.cu b/modules/gpu/src/cuda/row_filter.6.cu
new file mode 100644
index 000000000..548069d36
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.6.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<float3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.7.cu b/modules/gpu/src/cuda/row_filter.7.cu
new file mode 100644
index 000000000..8c5c09ed9
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.7.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<float4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.cu b/modules/gpu/src/cuda/row_filter.cu
deleted file mode 100644
index 39fc53fdc..000000000
--- a/modules/gpu/src/cuda/row_filter.cu
+++ /dev/null
@@ -1,390 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#if !defined CUDA_DISABLER
-
-#include "internal_shared.hpp"
-#include "opencv2/gpu/device/saturate_cast.hpp"
-#include "opencv2/gpu/device/vec_math.hpp"
-#include "opencv2/gpu/device/limits.hpp"
-#include "opencv2/gpu/device/border_interpolate.hpp"
-#include "opencv2/gpu/device/static_check.hpp"
-
-namespace cv { namespace gpu { namespace device
-{
-    namespace row_filter
-    {
-        #define MAX_KERNEL_SIZE 32
-
-        __constant__ float c_kernel[MAX_KERNEL_SIZE];
-
-        void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
-        {
-            if (stream == 0)
-                cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
-            else
-                cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
-        }
-
-        template <int KSIZE, typename T, typename D, typename B>
-        __global__ void linearRowFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
-        {
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 200)
-                const int BLOCK_DIM_X = 32;
-                const int BLOCK_DIM_Y = 8;
-                const int PATCH_PER_BLOCK = 4;
-                const int HALO_SIZE = 1;
-            #else
-                const int BLOCK_DIM_X = 32;
-                const int BLOCK_DIM_Y = 4;
-                const int PATCH_PER_BLOCK = 4;
-                const int HALO_SIZE = 1;
-            #endif
-
-            typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
-
-            __shared__ sum_t smem[BLOCK_DIM_Y][(PATCH_PER_BLOCK + 2 * HALO_SIZE) * BLOCK_DIM_X];
-
-            const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
-
-            if (y >= src.rows)
-                return;
-
-            const T* src_row = src.ptr(y);
-
-            const int xStart = blockIdx.x * (PATCH_PER_BLOCK * BLOCK_DIM_X) + threadIdx.x;
-
-            if (blockIdx.x > 0)
-            {
-                //Load left halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y][threadIdx.x + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart - (HALO_SIZE - j) * BLOCK_DIM_X]);
-            }
-            else
-            {
-                //Load left halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y][threadIdx.x + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_low(xStart - (HALO_SIZE - j) * BLOCK_DIM_X, src_row));
-            }
-
-            if (blockIdx.x + 2 < gridDim.x)
-            {
-                //Load main data
-                #pragma unroll
-                for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-                    smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart + j * BLOCK_DIM_X]);
-
-                //Load right halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y][threadIdx.x + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_X]);
-            }
-            else
-            {
-                //Load main data
-                #pragma unroll
-                for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-                    smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_high(xStart + j * BLOCK_DIM_X, src_row));
-
-                //Load right halo
-                #pragma unroll
-                for (int j = 0; j < HALO_SIZE; ++j)
-                    smem[threadIdx.y][threadIdx.x + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_high(xStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_X, src_row));
-            }
-
-            __syncthreads();
-
-            #pragma unroll
-            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
-            {
-                const int x = xStart + j * BLOCK_DIM_X;
-
-                if (x < src.cols)
-                {
-                    sum_t sum = VecTraits<sum_t>::all(0);
-
-                    #pragma unroll
-                    for (int k = 0; k < KSIZE; ++k)
-                        sum = sum + smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X - anchor + k] * c_kernel[k];
-
-                    dst(y, x) = saturate_cast<D>(sum);
-                }
-            }
-        }
-
-        template <int KSIZE, typename T, typename D, template<typename> class B>
-        void linearRowFilter_caller(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream)
-        {
-            int BLOCK_DIM_X;
-            int BLOCK_DIM_Y;
-            int PATCH_PER_BLOCK;
-
-            if (cc >= 20)
-            {
-                BLOCK_DIM_X = 32;
-                BLOCK_DIM_Y = 8;
-                PATCH_PER_BLOCK = 4;
-            }
-            else
-            {
-                BLOCK_DIM_X = 32;
-                BLOCK_DIM_Y = 4;
-                PATCH_PER_BLOCK = 4;
-            }
-
-            const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
-            const dim3 grid(divUp(src.cols, BLOCK_DIM_X * PATCH_PER_BLOCK), divUp(src.rows, BLOCK_DIM_Y));
-
-            B<T> brd(src.cols);
-
-            linearRowFilter<KSIZE, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, brd);
-            cudaSafeCall( cudaGetLastError() );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-
-        template <typename T, typename D>
-        void linearRowFilter_gpu(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream)
-        {
-            typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream);
-
-            static const caller_t callers[5][33] =
-            {
-                {
-                    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>,
-                    linearRowFilter_caller<17, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<18, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<19, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<20, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<21, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<22, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<23, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<24, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<25, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<26, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<27, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<28, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<29, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<30, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<31, T, D, BrdRowReflect101>,
-                    linearRowFilter_caller<32, 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>,
-                    linearRowFilter_caller<17, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<18, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<19, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<20, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<21, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<22, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<23, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<24, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<25, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<26, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<27, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<28, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<29, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<30, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<31, T, D, BrdRowReplicate>,
-                    linearRowFilter_caller<32, 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>,
-                    linearRowFilter_caller<17, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<18, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<19, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<20, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<21, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<22, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<23, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<24, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<25, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<26, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<27, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<28, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<29, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<30, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<31, T, D, BrdRowConstant>,
-                    linearRowFilter_caller<32, 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>,
-                    linearRowFilter_caller<17, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<18, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<19, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<20, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<21, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<22, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<23, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<24, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<25, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<26, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<27, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<28, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<29, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<30, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<31, T, D, BrdRowReflect>,
-                    linearRowFilter_caller<32, 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>,
-                    linearRowFilter_caller<17, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<18, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<19, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<20, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<21, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<22, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<23, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<24, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<25, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<26, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<27, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<28, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<29, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<30, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<31, T, D, BrdRowWrap>,
-                    linearRowFilter_caller<32, T, D, BrdRowWrap>
-                }
-            };
-
-            loadKernel(kernel, ksize, stream);
-
-            callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
-        }
-
-        template void linearRowFilter_gpu<uchar , float >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<uchar3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<uchar4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<short3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<int   , float >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<float , float >(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<float3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-        template void linearRowFilter_gpu<float4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-    } // namespace row_filter
-}}} // namespace cv { namespace gpu { namespace device
-
-
-#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.h b/modules/gpu/src/cuda/row_filter.h
new file mode 100644
index 000000000..0da2dfe0c
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.h
@@ -0,0 +1,377 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/vec_math.hpp"
+#include "opencv2/gpu/device/border_interpolate.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
+{
+    #define MAX_KERNEL_SIZE 32
+
+    __constant__ float c_kernel[MAX_KERNEL_SIZE];
+
+    void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
+    {
+        if (stream == 0)
+            cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
+    }
+
+    template <int KSIZE, typename T, typename D, typename B>
+    __global__ void linearRowFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
+    {
+        #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 200)
+            const int BLOCK_DIM_X = 32;
+            const int BLOCK_DIM_Y = 8;
+            const int PATCH_PER_BLOCK = 4;
+            const int HALO_SIZE = 1;
+        #else
+            const int BLOCK_DIM_X = 32;
+            const int BLOCK_DIM_Y = 4;
+            const int PATCH_PER_BLOCK = 4;
+            const int HALO_SIZE = 1;
+        #endif
+
+        typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type sum_t;
+
+        __shared__ sum_t smem[BLOCK_DIM_Y][(PATCH_PER_BLOCK + 2 * HALO_SIZE) * BLOCK_DIM_X];
+
+        const int y = blockIdx.y * BLOCK_DIM_Y + threadIdx.y;
+
+        if (y >= src.rows)
+            return;
+
+        const T* src_row = src.ptr(y);
+
+        const int xStart = blockIdx.x * (PATCH_PER_BLOCK * BLOCK_DIM_X) + threadIdx.x;
+
+        if (blockIdx.x > 0)
+        {
+            //Load left halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y][threadIdx.x + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart - (HALO_SIZE - j) * BLOCK_DIM_X]);
+        }
+        else
+        {
+            //Load left halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y][threadIdx.x + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_low(xStart - (HALO_SIZE - j) * BLOCK_DIM_X, src_row));
+        }
+
+        if (blockIdx.x + 2 < gridDim.x)
+        {
+            //Load main data
+            #pragma unroll
+            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+                smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart + j * BLOCK_DIM_X]);
+
+            //Load right halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y][threadIdx.x + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(src_row[xStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_X]);
+        }
+        else
+        {
+            //Load main data
+            #pragma unroll
+            for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+                smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_high(xStart + j * BLOCK_DIM_X, src_row));
+
+            //Load right halo
+            #pragma unroll
+            for (int j = 0; j < HALO_SIZE; ++j)
+                smem[threadIdx.y][threadIdx.x + (PATCH_PER_BLOCK + HALO_SIZE) * BLOCK_DIM_X + j * BLOCK_DIM_X] = saturate_cast<sum_t>(brd.at_high(xStart + (PATCH_PER_BLOCK + j) * BLOCK_DIM_X, src_row));
+        }
+
+        __syncthreads();
+
+        #pragma unroll
+        for (int j = 0; j < PATCH_PER_BLOCK; ++j)
+        {
+            const int x = xStart + j * BLOCK_DIM_X;
+
+            if (x < src.cols)
+            {
+                sum_t sum = VecTraits<sum_t>::all(0);
+
+                #pragma unroll
+                for (int k = 0; k < KSIZE; ++k)
+                    sum = sum + smem[threadIdx.y][threadIdx.x + HALO_SIZE * BLOCK_DIM_X + j * BLOCK_DIM_X - anchor + k] * c_kernel[k];
+
+                dst(y, x) = saturate_cast<D>(sum);
+            }
+        }
+    }
+
+    template <int KSIZE, typename T, typename D, template<typename> class B>
+    void caller(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream)
+    {
+        int BLOCK_DIM_X;
+        int BLOCK_DIM_Y;
+        int PATCH_PER_BLOCK;
+
+        if (cc >= 20)
+        {
+            BLOCK_DIM_X = 32;
+            BLOCK_DIM_Y = 8;
+            PATCH_PER_BLOCK = 4;
+        }
+        else
+        {
+            BLOCK_DIM_X = 32;
+            BLOCK_DIM_Y = 4;
+            PATCH_PER_BLOCK = 4;
+        }
+
+        const dim3 block(BLOCK_DIM_X, BLOCK_DIM_Y);
+        const dim3 grid(divUp(src.cols, BLOCK_DIM_X * PATCH_PER_BLOCK), divUp(src.rows, BLOCK_DIM_Y));
+
+        B<T> brd(src.cols);
+
+        linearRowFilter<KSIZE, T, D><<<grid, block, 0, stream>>>(src, dst, anchor, brd);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+namespace filter
+{
+    template <typename T, typename D>
+    void linearRow(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream)
+    {
+        typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<D> dst, int anchor, int cc, cudaStream_t stream);
+
+        static const caller_t callers[5][33] =
+        {
+            {
+                0,
+                ::caller< 1, T, D, BrdRowReflect101>,
+                ::caller< 2, T, D, BrdRowReflect101>,
+                ::caller< 3, T, D, BrdRowReflect101>,
+                ::caller< 4, T, D, BrdRowReflect101>,
+                ::caller< 5, T, D, BrdRowReflect101>,
+                ::caller< 6, T, D, BrdRowReflect101>,
+                ::caller< 7, T, D, BrdRowReflect101>,
+                ::caller< 8, T, D, BrdRowReflect101>,
+                ::caller< 9, T, D, BrdRowReflect101>,
+                ::caller<10, T, D, BrdRowReflect101>,
+                ::caller<11, T, D, BrdRowReflect101>,
+                ::caller<12, T, D, BrdRowReflect101>,
+                ::caller<13, T, D, BrdRowReflect101>,
+                ::caller<14, T, D, BrdRowReflect101>,
+                ::caller<15, T, D, BrdRowReflect101>,
+                ::caller<16, T, D, BrdRowReflect101>,
+                ::caller<17, T, D, BrdRowReflect101>,
+                ::caller<18, T, D, BrdRowReflect101>,
+                ::caller<19, T, D, BrdRowReflect101>,
+                ::caller<20, T, D, BrdRowReflect101>,
+                ::caller<21, T, D, BrdRowReflect101>,
+                ::caller<22, T, D, BrdRowReflect101>,
+                ::caller<23, T, D, BrdRowReflect101>,
+                ::caller<24, T, D, BrdRowReflect101>,
+                ::caller<25, T, D, BrdRowReflect101>,
+                ::caller<26, T, D, BrdRowReflect101>,
+                ::caller<27, T, D, BrdRowReflect101>,
+                ::caller<28, T, D, BrdRowReflect101>,
+                ::caller<29, T, D, BrdRowReflect101>,
+                ::caller<30, T, D, BrdRowReflect101>,
+                ::caller<31, T, D, BrdRowReflect101>,
+                ::caller<32, T, D, BrdRowReflect101>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdRowReplicate>,
+                ::caller< 2, T, D, BrdRowReplicate>,
+                ::caller< 3, T, D, BrdRowReplicate>,
+                ::caller< 4, T, D, BrdRowReplicate>,
+                ::caller< 5, T, D, BrdRowReplicate>,
+                ::caller< 6, T, D, BrdRowReplicate>,
+                ::caller< 7, T, D, BrdRowReplicate>,
+                ::caller< 8, T, D, BrdRowReplicate>,
+                ::caller< 9, T, D, BrdRowReplicate>,
+                ::caller<10, T, D, BrdRowReplicate>,
+                ::caller<11, T, D, BrdRowReplicate>,
+                ::caller<12, T, D, BrdRowReplicate>,
+                ::caller<13, T, D, BrdRowReplicate>,
+                ::caller<14, T, D, BrdRowReplicate>,
+                ::caller<15, T, D, BrdRowReplicate>,
+                ::caller<16, T, D, BrdRowReplicate>,
+                ::caller<17, T, D, BrdRowReplicate>,
+                ::caller<18, T, D, BrdRowReplicate>,
+                ::caller<19, T, D, BrdRowReplicate>,
+                ::caller<20, T, D, BrdRowReplicate>,
+                ::caller<21, T, D, BrdRowReplicate>,
+                ::caller<22, T, D, BrdRowReplicate>,
+                ::caller<23, T, D, BrdRowReplicate>,
+                ::caller<24, T, D, BrdRowReplicate>,
+                ::caller<25, T, D, BrdRowReplicate>,
+                ::caller<26, T, D, BrdRowReplicate>,
+                ::caller<27, T, D, BrdRowReplicate>,
+                ::caller<28, T, D, BrdRowReplicate>,
+                ::caller<29, T, D, BrdRowReplicate>,
+                ::caller<30, T, D, BrdRowReplicate>,
+                ::caller<31, T, D, BrdRowReplicate>,
+                ::caller<32, T, D, BrdRowReplicate>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdRowConstant>,
+                ::caller< 2, T, D, BrdRowConstant>,
+                ::caller< 3, T, D, BrdRowConstant>,
+                ::caller< 4, T, D, BrdRowConstant>,
+                ::caller< 5, T, D, BrdRowConstant>,
+                ::caller< 6, T, D, BrdRowConstant>,
+                ::caller< 7, T, D, BrdRowConstant>,
+                ::caller< 8, T, D, BrdRowConstant>,
+                ::caller< 9, T, D, BrdRowConstant>,
+                ::caller<10, T, D, BrdRowConstant>,
+                ::caller<11, T, D, BrdRowConstant>,
+                ::caller<12, T, D, BrdRowConstant>,
+                ::caller<13, T, D, BrdRowConstant>,
+                ::caller<14, T, D, BrdRowConstant>,
+                ::caller<15, T, D, BrdRowConstant>,
+                ::caller<16, T, D, BrdRowConstant>,
+                ::caller<17, T, D, BrdRowConstant>,
+                ::caller<18, T, D, BrdRowConstant>,
+                ::caller<19, T, D, BrdRowConstant>,
+                ::caller<20, T, D, BrdRowConstant>,
+                ::caller<21, T, D, BrdRowConstant>,
+                ::caller<22, T, D, BrdRowConstant>,
+                ::caller<23, T, D, BrdRowConstant>,
+                ::caller<24, T, D, BrdRowConstant>,
+                ::caller<25, T, D, BrdRowConstant>,
+                ::caller<26, T, D, BrdRowConstant>,
+                ::caller<27, T, D, BrdRowConstant>,
+                ::caller<28, T, D, BrdRowConstant>,
+                ::caller<29, T, D, BrdRowConstant>,
+                ::caller<30, T, D, BrdRowConstant>,
+                ::caller<31, T, D, BrdRowConstant>,
+                ::caller<32, T, D, BrdRowConstant>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdRowReflect>,
+                ::caller< 2, T, D, BrdRowReflect>,
+                ::caller< 3, T, D, BrdRowReflect>,
+                ::caller< 4, T, D, BrdRowReflect>,
+                ::caller< 5, T, D, BrdRowReflect>,
+                ::caller< 6, T, D, BrdRowReflect>,
+                ::caller< 7, T, D, BrdRowReflect>,
+                ::caller< 8, T, D, BrdRowReflect>,
+                ::caller< 9, T, D, BrdRowReflect>,
+                ::caller<10, T, D, BrdRowReflect>,
+                ::caller<11, T, D, BrdRowReflect>,
+                ::caller<12, T, D, BrdRowReflect>,
+                ::caller<13, T, D, BrdRowReflect>,
+                ::caller<14, T, D, BrdRowReflect>,
+                ::caller<15, T, D, BrdRowReflect>,
+                ::caller<16, T, D, BrdRowReflect>,
+                ::caller<17, T, D, BrdRowReflect>,
+                ::caller<18, T, D, BrdRowReflect>,
+                ::caller<19, T, D, BrdRowReflect>,
+                ::caller<20, T, D, BrdRowReflect>,
+                ::caller<21, T, D, BrdRowReflect>,
+                ::caller<22, T, D, BrdRowReflect>,
+                ::caller<23, T, D, BrdRowReflect>,
+                ::caller<24, T, D, BrdRowReflect>,
+                ::caller<25, T, D, BrdRowReflect>,
+                ::caller<26, T, D, BrdRowReflect>,
+                ::caller<27, T, D, BrdRowReflect>,
+                ::caller<28, T, D, BrdRowReflect>,
+                ::caller<29, T, D, BrdRowReflect>,
+                ::caller<30, T, D, BrdRowReflect>,
+                ::caller<31, T, D, BrdRowReflect>,
+                ::caller<32, T, D, BrdRowReflect>
+            },
+            {
+                0,
+                ::caller< 1, T, D, BrdRowWrap>,
+                ::caller< 2, T, D, BrdRowWrap>,
+                ::caller< 3, T, D, BrdRowWrap>,
+                ::caller< 4, T, D, BrdRowWrap>,
+                ::caller< 5, T, D, BrdRowWrap>,
+                ::caller< 6, T, D, BrdRowWrap>,
+                ::caller< 7, T, D, BrdRowWrap>,
+                ::caller< 8, T, D, BrdRowWrap>,
+                ::caller< 9, T, D, BrdRowWrap>,
+                ::caller<10, T, D, BrdRowWrap>,
+                ::caller<11, T, D, BrdRowWrap>,
+                ::caller<12, T, D, BrdRowWrap>,
+                ::caller<13, T, D, BrdRowWrap>,
+                ::caller<14, T, D, BrdRowWrap>,
+                ::caller<15, T, D, BrdRowWrap>,
+                ::caller<16, T, D, BrdRowWrap>,
+                ::caller<17, T, D, BrdRowWrap>,
+                ::caller<18, T, D, BrdRowWrap>,
+                ::caller<19, T, D, BrdRowWrap>,
+                ::caller<20, T, D, BrdRowWrap>,
+                ::caller<21, T, D, BrdRowWrap>,
+                ::caller<22, T, D, BrdRowWrap>,
+                ::caller<23, T, D, BrdRowWrap>,
+                ::caller<24, T, D, BrdRowWrap>,
+                ::caller<25, T, D, BrdRowWrap>,
+                ::caller<26, T, D, BrdRowWrap>,
+                ::caller<27, T, D, BrdRowWrap>,
+                ::caller<28, T, D, BrdRowWrap>,
+                ::caller<29, T, D, BrdRowWrap>,
+                ::caller<30, T, D, BrdRowWrap>,
+                ::caller<31, T, D, BrdRowWrap>,
+                ::caller<32, T, D, BrdRowWrap>
+            }
+        };
+
+        loadKernel(kernel, ksize, stream);
+
+        callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
+    }
+}
diff --git a/modules/gpu/src/filtering.cpp b/modules/gpu/src/filtering.cpp
index 77ed46e15..6b7135ab6 100644
--- a/modules/gpu/src/filtering.cpp
+++ b/modules/gpu/src/filtering.cpp
@@ -830,20 +830,14 @@ void cv::gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& ke
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Separable Linear Filter
 
-namespace cv { namespace gpu { namespace device
+namespace filter
 {
-    namespace row_filter
-    {
-        template <typename T, typename D>
-        void linearRowFilter_gpu(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-    }
+    template <typename T, typename D>
+    void linearRow(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
 
-    namespace column_filter
-    {
-        template <typename T, typename D>
-        void linearColumnFilter_gpu(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
-    }
-}}}
+    template <typename T, typename D>
+    void linearColumn(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
 
 namespace
 {
@@ -899,8 +893,6 @@ namespace
 
 Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor, int borderType)
 {
-    using namespace ::cv::gpu::device::row_filter;
-
     static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterRow_8u_C1R, 0, 0, nppiFilterRow_8u_C4R};
 
     if ((bufType == srcType) && (srcType == CV_8UC1 || srcType == CV_8UC4))
@@ -940,28 +932,28 @@ Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType,
     switch (srcType)
     {
     case CV_8UC1:
-        func = linearRowFilter_gpu<uchar, float>;
+        func = filter::linearRow<uchar, float>;
         break;
     case CV_8UC3:
-        func = linearRowFilter_gpu<uchar3, float3>;
+        func = filter::linearRow<uchar3, float3>;
         break;
     case CV_8UC4:
-        func = linearRowFilter_gpu<uchar4, float4>;
+        func = filter::linearRow<uchar4, float4>;
         break;
     case CV_16SC3:
-        func = linearRowFilter_gpu<short3, float3>;
+        func = filter::linearRow<short3, float3>;
         break;
     case CV_32SC1:
-        func = linearRowFilter_gpu<int, float>;
+        func = filter::linearRow<int, float>;
         break;
     case CV_32FC1:
-        func = linearRowFilter_gpu<float, float>;
+        func = filter::linearRow<float, float>;
         break;
     case CV_32FC3:
-        func = linearRowFilter_gpu<float3, float3>;
+        func = filter::linearRow<float3, float3>;
         break;
     case CV_32FC4:
-        func = linearRowFilter_gpu<float4, float4>;
+        func = filter::linearRow<float4, float4>;
         break;
     }
 
@@ -1020,8 +1012,6 @@ namespace
 
 Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor, int borderType)
 {
-    using namespace ::cv::gpu::device::column_filter;
-
     static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterColumn_8u_C1R, 0, 0, nppiFilterColumn_8u_C4R};
 
     if ((bufType == dstType) && (bufType == CV_8UC1 || bufType == CV_8UC4))
@@ -1061,28 +1051,28 @@ Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int ds
     switch (dstType)
     {
     case CV_8UC1:
-        func = linearColumnFilter_gpu<float, uchar>;
+        func = filter::linearColumn<float, uchar>;
         break;
     case CV_8UC3:
-        func = linearColumnFilter_gpu<float3, uchar3>;
+        func = filter::linearColumn<float3, uchar3>;
         break;
     case CV_8UC4:
-        func = linearColumnFilter_gpu<float4, uchar4>;
+        func = filter::linearColumn<float4, uchar4>;
         break;
     case CV_16SC3:
-        func = linearColumnFilter_gpu<float3, short3>;
+        func = filter::linearColumn<float3, short3>;
         break;
     case CV_32SC1:
-        func = linearColumnFilter_gpu<float, int>;
+        func = filter::linearColumn<float, int>;
         break;
     case CV_32FC1:
-        func = linearColumnFilter_gpu<float, float>;
+        func = filter::linearColumn<float, float>;
         break;
     case CV_32FC3:
-        func = linearColumnFilter_gpu<float3, float3>;
+        func = filter::linearColumn<float3, float3>;
         break;
     case CV_32FC4:
-        func = linearColumnFilter_gpu<float4, float4>;
+        func = filter::linearColumn<float4, float4>;
         break;
     }
 

From afff9cf71634a96a491fdc7d195e267ba126871e Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 26 Oct 2012 15:49:39 +0400
Subject: [PATCH 064/155] Optimized buffers reuse in gpu module:

ensureSizeIsEnough now doesn't reallocate memory, if buffer is small submat of big matrix
fixed createContinous according new changes
---
 modules/core/include/opencv2/core/gpumat.hpp | 16 ---------
 modules/core/src/gpumat.cpp                  | 37 ++++++++++++++++++++
 modules/gpu/test/test_gpumat.cpp             | 34 ++++++++++++++++++
 3 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/modules/core/include/opencv2/core/gpumat.hpp b/modules/core/include/opencv2/core/gpumat.hpp
index 2830a9e94..73da7e7a8 100644
--- a/modules/core/include/opencv2/core/gpumat.hpp
+++ b/modules/core/include/opencv2/core/gpumat.hpp
@@ -545,22 +545,6 @@ namespace cv { namespace gpu
         ensureSizeIsEnough(size.height, size.width, type, m);
     }
 
-    inline void createContinuous(int rows, int cols, int type, GpuMat& m)
-    {
-        int area = rows * cols;
-        if (!m.isContinuous() || m.type() != type || m.size().area() != area)
-            ensureSizeIsEnough(1, area, type, m);
-        m = m.reshape(0, rows);
-    }
-
-    inline void ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
-    {
-        if (m.type() == type && m.rows >= rows && m.cols >= cols)
-            m = m(Rect(0, 0, cols, rows));
-        else
-            m.create(rows, cols, type);
-    }
-
     inline GpuMat allocMatFromBuf(int rows, int cols, int type, GpuMat &mat)
     {
         if (!mat.empty() && mat.type() == type && mat.rows >= rows && mat.cols >= cols)
diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
index fc291a862..afd7115b0 100644
--- a/modules/core/src/gpumat.cpp
+++ b/modules/core/src/gpumat.cpp
@@ -704,6 +704,43 @@ cv::Mat::Mat(const GpuMat& m) : flags(0), dims(0), rows(0), cols(0), data(0), re
     m.download(*this);
 }
 
+void cv::gpu::createContinuous(int rows, int cols, int type, GpuMat& m)
+{
+    int area = rows * cols;
+    if (m.empty() || m.type() != type || !m.isContinuous() || m.size().area() < area)
+        m.create(1, area, type);
+
+    m.cols = cols;
+    m.rows = rows;
+    m.step = m.elemSize() * cols;
+    m.flags |= Mat::CONTINUOUS_FLAG;
+}
+
+void cv::gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m)
+{
+    if (m.empty() || m.type() != type || m.data != m.datastart)
+        m.create(rows, cols, type);
+    else
+    {
+        const size_t esz = m.elemSize();
+        const ptrdiff_t delta2 = m.dataend - m.datastart;
+
+        const size_t minstep = m.cols * esz;
+
+        Size wholeSize;
+        wholeSize.height = std::max(static_cast<int>((delta2 - minstep) / m.step + 1), m.rows);
+        wholeSize.width = std::max(static_cast<int>((delta2 - m.step * (wholeSize.height - 1)) / esz), m.cols);
+
+        if (wholeSize.height < rows || wholeSize.width < cols)
+            m.create(rows, cols, type);
+        else
+        {
+            m.cols = cols;
+            m.rows = rows;
+        }
+    }
+}
+
 namespace
 {
     class GpuFuncTable
diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp
index 7a4a61623..9d7e545de 100644
--- a/modules/gpu/test/test_gpumat.cpp
+++ b/modules/gpu/test/test_gpumat.cpp
@@ -324,6 +324,40 @@ INSTANTIATE_TEST_CASE_P(GPU_GpuMat, ConvertTo, testing::Combine(
     ALL_DEPTH,
     WHOLE_SUBMAT));
 
+////////////////////////////////////////////////////////////////////////////////
+// ensureSizeIsEnough
+
+struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    virtual void SetUp()
+    {
+        cv::gpu::DeviceInfo devInfo = GetParam();
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+TEST_P(EnsureSizeIsEnough, BufferReuse)
+{
+    cv::gpu::GpuMat buffer(100, 100, CV_8U);
+    cv::gpu::GpuMat old = buffer;
+
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
+    EXPECT_EQ(10, buffer.rows);
+    EXPECT_EQ(20, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
+    EXPECT_EQ(20, buffer.rows);
+    EXPECT_EQ(30, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
+
 } // namespace
 
 #endif // HAVE_CUDA

From 580d8173e5acc12cc0a5a6997fe8af73efffe619 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 12 Nov 2012 11:54:40 +0400
Subject: [PATCH 065/155] refactor computing of scaling factor

---
 modules/gpu/src/softcascade.cpp | 53 ++++++---------------------------
 1 file changed, 9 insertions(+), 44 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index fdde2618e..a69be9239 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -70,6 +70,15 @@ cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale
 
     objSize.x  = cv::saturate_cast<uchar>(oct.size.x * relScale);
     objSize.y  = cv::saturate_cast<uchar>(oct.size.y * relScale);
+
+    // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
+    if (fabs(relScale - 1.f) < FLT_EPSILON)
+        scaling[0] = scaling[1] = 1.f;
+    else
+    {
+        scaling[0] = (relScale < 1.f) ? 0.89f * ::pow(relScale, 1.099f / ::log(2)) : 1.f;
+        scaling[1] = relScale * relScale;
+    }
 }
 
 namespace cv { namespace gpu { namespace device {
@@ -91,38 +100,6 @@ namespace imgproc {
 
 struct cv::gpu::SCascade::Fields
 {
-    struct CascadeIntrinsics
-    {
-        static const float lambda = 1.099f, a = 0.89f;
-
-        static float getFor(int channel, float scaling)
-        {
-            CV_Assert(channel < 10);
-
-            if (fabs(scaling - 1.f) < FLT_EPSILON)
-                return 1.f;
-
-            // according to R. Benenson, M. Mathias, R. Timofte and L. Van Gool's and Dallal's papers
-            static const float A[2][2] =
-            {   //channel <= 6, otherwise
-                {        0.89f, 1.f}, // down
-                {        1.00f, 1.f}  // up
-            };
-
-            static const float B[2][2] =
-            {   //channel <= 6,  otherwise
-                { 1.099f / ::log(2), 2.f}, // down
-                {             0.f, 2.f}  // up
-            };
-
-            float a = A[(int)(scaling >= 1)][(int)(channel > 6)];
-            float b = B[(int)(scaling >= 1)][(int)(channel > 6)];
-
-            // printf("!!! scaling: %f %f %f -> %f\n", scaling, a, b, a * pow(scaling, b));
-            return a * ::pow(scaling, b);
-        }
-    };
-
     static Fields* parseCascade(const FileNode &root, const float mins, const float maxs)
     {
         static const char *const SC_STAGE_TYPE          = "stageType";
@@ -281,8 +258,6 @@ struct cv::gpu::SCascade::Fields
             int fit = fitOctave(voctaves, logScale);
 
             Level level(fit, voctaves[fit], scale, width, height);
-            level.scaling[0] = CascadeIntrinsics::getFor(0, level.relScale);
-            level.scaling[1] = CascadeIntrinsics::getFor(9, level.relScale);
 
             if (!width || !height)
                 break;
@@ -294,16 +269,6 @@ struct cv::gpu::SCascade::Fields
 
             if (::fabs(scale - maxs) < FLT_EPSILON) break;
             scale = ::std::min(maxs, ::expf(::log(scale) + logFactor));
-
-            // std::cout << "level " << sc
-            //           << " octeve "
-            //           << vlevels[sc].octave
-            //           << " relScale "
-            //           << vlevels[sc].relScale
-            //           << " " << vlevels[sc].shrScale
-            //           << " [" << (int)vlevels[sc].objSize.x
-            //           << " " <<  (int)vlevels[sc].objSize.y << "] ["
-            // <<  (int)vlevels[sc].workRect.x << " " <<  (int)vlevels[sc].workRect.y << "]" << std::endl;
         }
 
         cv::Mat hlevels(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );

From aa92be34d603a154b6e734d3a52a43507ab150e2 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 12 Nov 2012 16:37:18 +0400
Subject: [PATCH 066/155] GK107 Policy

---
 modules/gpu/src/cuda/isf-sc.cu        | 284 ++++++++++----------------
 modules/gpu/src/icf.hpp               |  26 ++-
 modules/gpu/src/softcascade.cpp       |  41 ++--
 modules/gpu/test/test_softcascade.cpp |  10 +-
 4 files changed, 149 insertions(+), 212 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 0de2d8e37..ac4b8f0e8 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -161,192 +161,128 @@ namespace icf {
     }
 
     texture<float2,  cudaTextureType2D, cudaReadModeElementType> troi;
-#if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
-    template<bool isUp>
-    __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
-        const int downscales)
+
+template<typename Policy>
+template<bool isUp>
+__device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndetections, uint* ctr, const int downscales) const
+{
+    const int y = blockIdx.y * blockDim.y + threadIdx.y;
+    const int x = blockIdx.x;
+
+    // load Lavel
+    __shared__ Level level;
+
+    // check POI
+    __shared__ volatile char roiCache[Policy::STA_Y];
+
+    if (!threadIdx.y && !threadIdx.x)
+        ((float2*)roiCache)[threadIdx.x] = tex2D(troi, blockIdx.y, x);
+
+    __syncthreads();
+
+    if (!roiCache[threadIdx.y]) return;
+
+    if (!threadIdx.x)
+        level = levels[downscales + blockIdx.z];
+
+    if(x >= level.workRect.x || y >= level.workRect.y) return;
+
+    int st = level.octave * level.step;
+    const int stEnd = st + level.step;
+
+    float confidence = 0.f;
+    for(; st < stEnd; st += Policy::WARP)
     {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = blockIdx.x;
+        const int nId = (st + threadIdx.x) * 3;
 
-        // load Lavel
-        __shared__ Level level;
+        Node node = nodes[nId];
 
-        // check POI
-        __shared__ volatile char roiCache[8];
-        if (!threadIdx.y && !threadIdx.x)
-            ((float2*)roiCache)[threadIdx.x] = tex2D(troi, blockIdx.y, x);
+        float threshold = rescale<isUp>(level, node);
+        int sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
 
-        __syncthreads();
+        int next = 1 + (int)(sum >= threshold);
 
-        if (!roiCache[threadIdx.y]) return;
+        node = nodes[nId + next];
+        threshold = rescale<isUp>(level, node);
+        sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
 
-        if (!threadIdx.x)
-            level = levels[downscales + blockIdx.z];
+        const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
+        float impact = leaves[(st + threadIdx.x) * 4 + lShift];
 
-        if(x >= level.workRect.x || y >= level.workRect.y) return;
-
-        Octave octave = octaves[level.octave];
-        int st = octave.index * octave.stages;
-        const int stEnd = st + 1024;
-
-        float confidence = 0.f;
-
-        for(; st < stEnd; st += 32)
-        {
-
-            const int nId = (st + threadIdx.x) * 3;
-            dprintf("\n\n%d: stage: %d %d\n",threadIdx.x, st, nId);
-            Node node = nodes[nId];
-
-            float threshold = rescale<isUp>(level, node);
-            int sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
-
-            int next = 1 + (int)(sum >= threshold);
-            dprintf("%d: go: %d (%d >= %f)\n\n" ,threadIdx.x, next, sum, threshold);
-
-            node = nodes[nId + next];
-            threshold = rescale<isUp>(level, node);
-            sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
-
-            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-            float impact = leaves[(st + threadIdx.x) * 4 + lShift];
-
-            dprintf("%d: decided: %d (%d >= %f) %d %f\n\n" ,threadIdx.x, next, sum, threshold, lShift, impact);
-            dprintf("%d: extracted stage: %f\n",threadIdx.x, stages[(st + threadIdx.x)]);
-            dprintf("%d: computed  score: %f\n",threadIdx.x, impact);
 #pragma unroll
-            // scan on shuffl functions
-            for (int i = 1; i < 32; i *= 2)
-            {
-                const float n = __shfl_up(impact, i, 32);
-
-                if (threadIdx.x >= i)
-                    impact += n;
-            }
-
-            dprintf("%d: impact scaned %f\n" ,threadIdx.x, impact);
-
-            confidence += impact;
-            if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
-        }
-
-        if(!threadIdx.x && st == stEnd &&  ((confidence - FLT_EPSILON) >= 0))
+        // scan on shuffl functions
+        for (int i = 1; i < Policy::WARP; i *= 2)
         {
-            int idx = atomicInc(ctr, ndetections);
-            // store detection
-            objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
-                __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
+            const float n = __shfl_up(impact, i, Policy::WARP);
+
+            if (threadIdx.x >= i)
+                impact += n;
         }
+
+        confidence += impact;
+        if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
     }
-#else
-    template<bool isUp>
-    __global__ void test_kernel_warp(const Level* levels, const Octave* octaves, const float* stages,
-        const Node* nodes, const float* leaves, Detection* objects, const uint ndetections, uint* ctr,
-        const int downscales)
+
+    if(!threadIdx.x && st == stEnd &&  ((confidence - FLT_EPSILON) >= 0))
     {
-        const int y = blockIdx.y * blockDim.y + threadIdx.y;
-        const int x = blockIdx.x * blockDim.x + threadIdx.x;
-        Level level = levels[blockIdx.z];
-
-        // if (blockIdx.z != 31) return;
-        if(x >= level.workRect.x || y >= level.workRect.y) return;
-
-        // int roi = tex2D(troi, x, y);
-        // printf("%d\n", roi);
-        // if (!roi) return;
-
-        Octave octave = octaves[level.octave];
-
-        int st = octave.index * octave.stages;
-        const int stEnd = st + 1000;//octave.stages;
-
-        float confidence = 0.f;
-
-        for(; st < stEnd; ++st)
-        {
-            dprintf("\n\nstage: %d\n", st);
-            const int nId = st * 3;
-            Node node = nodes[nId];
-
-            dprintf("Node: [%d %d %d %d] %d %d\n", node.rect.x, node.rect.y, node.rect.z, node.rect.w,
-                node.threshold >> 28, node.threshold & 0x0FFFFFFFU);
-
-            float threshold = rescale<isUp>(level, node);
-            int sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
-
-            dprintf("Node: [%d %d %d %d] %f\n", node.rect.x, node.rect.y, node.rect.z,
-                node.rect.w, threshold);
-
-            int next = 1 + (int)(sum >= threshold);
-            dprintf("go: %d (%d >= %f)\n\n" ,next, sum, threshold);
-
-            node = nodes[nId + next];
-            threshold = rescale<isUp>(level, node);
-            sum = get<isUp>(x, y + (node.threshold >> 28) * 121, node.rect);
-
-            const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
-            float impact = leaves[st * 4 + lShift];
-            confidence += impact;
-
-            if (confidence <= stages[st]) st = stEnd + 10;
-            dprintf("decided: %d (%d >= %f) %d %f\n\n" ,next, sum, threshold, lShift, impact);
-            dprintf("extracted stage: %f\n", stages[st]);
-            dprintf("computed  score: %f\n\n", confidence);
-        }
-
-        if(st == stEnd)
-        {
-            int idx = atomicInc(ctr, ndetections);
-            // store detection
-            objects[idx] = Detection(__float2int_rn(x * octave.shrinkage),
-                __float2int_rn(y * octave.shrinkage), level.objSize.x, level.objSize.y, confidence);
-        }
-    }
-#endif
-
-    template<>
-    void CascadeInvoker<CascadePolicy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-        PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const
-    {
-        int fw = 160;
-        int fh = 120;
-
-        dim3 block(32, 8);
-        dim3 grid(fw, fh / 8, (scale == -1) ? downscales : 1);
-
-        uint* ctr = (uint*)(counter.ptr(0));
-        Detection* det = (Detection*)objects.ptr();
-        uint max_det = objects.cols / sizeof(Detection);
-
-        cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
-        cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
-
-        cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
-        cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
-
-        if (scale == -1)
-        {
-            test_kernel_warp<false><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, 0);
-            cudaSafeCall( cudaGetLastError());
-
-            grid = dim3(fw, fh / 8, 47 - downscales);
-            test_kernel_warp<true><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, downscales);
-        }
-        else
-        {
-            if (scale >= downscales)
-                test_kernel_warp<true><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
-            else
-                test_kernel_warp<false><<<grid, block, 0, stream>>>(levels, octaves, stages, nodes, leaves, det, max_det, ctr, scale);
-        }
-
-        if (!stream)
-        {
-            cudaSafeCall( cudaGetLastError());
-            cudaSafeCall( cudaDeviceSynchronize());
-        }
+        int idx = atomicInc(ctr, ndetections);
+        objects[idx] = Detection(__float2int_rn(x * Policy::SHRINKAGE),
+            __float2int_rn(y * Policy::SHRINKAGE), level.objSize.x, level.objSize.y, confidence);
     }
 }
+
+template<typename Policy, bool isUp>
+__global__ void soft_cascade(const CascadeInvoker<Policy> invoker, Detection* objects, const uint n, uint* ctr, const int downs)
+{
+    invoker.template detect<isUp>(objects, n, ctr, downs);
+}
+
+template<typename Policy>
+void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
+    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const
+{
+    int fw = 160;
+    int fh = 120;
+
+    dim3 grid(fw, fh / Policy::STA_Y, (scale == -1) ? downscales : 1);
+
+    uint* ctr = (uint*)(counter.ptr(0));
+    Detection* det = (Detection*)objects.ptr();
+    uint max_det = objects.cols / sizeof(Detection);
+
+    cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
+    cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
+
+    cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
+    cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
+
+    const CascadeInvoker<Policy> inv = *this;
+
+    if (scale == -1)
+    {
+        soft_cascade<Policy, false><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, 0);
+        cudaSafeCall( cudaGetLastError());
+
+        grid = dim3(fw, fh / Policy::STA_Y, scales - downscales);
+        soft_cascade<Policy, true><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, downscales);
+    }
+    else
+    {
+        if (scale >= downscales)
+            soft_cascade<Policy, true><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, scale);
+        else
+            soft_cascade<Policy, false><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, scale);
+    }
+
+    if (!stream)
+    {
+        cudaSafeCall( cudaGetLastError());
+        cudaSafeCall( cudaDeviceSynchronize());
+    }
+}
+
+template void CascadeInvoker<GK107PolicyX4>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
+    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const;
+
+}
 }}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 60df55882..8eb080e23 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -72,9 +72,9 @@ struct __align__(16) Octave
 struct __align__(8) Level //is actually 24 bytes
 {
     int octave;
+    int step;
 
     float relScale;
-    float shrScale;   // used for marking detection
     float scaling[2]; // calculated according to Dollal paper
 
     // for 640x480 we can not get overflow
@@ -115,31 +115,41 @@ struct __align__(16) Detection
     : x(_x), y(_y), w(_w), h(_h), confidence(c), kind(0) {};
 };
 
-struct CascadePolicy
+struct GK107PolicyX4
 {
-    enum {STA_X = 32, STA_Y = 8};
+    enum {WARP = 32, STA_X = WARP, STA_Y = 8, SHRINKAGE = 4};
+    static const dim3 block()
+    {
+        return dim3(GK107PolicyX4::STA_X, GK107PolicyX4::STA_Y);
+    }
 };
 
 template<typename Policy>
 struct CascadeInvoker
 {
-    CascadeInvoker(): levels(0), octaves(0), stages(0), nodes(0), leaves(0) {}
+    CascadeInvoker(): levels(0), stages(0), nodes(0), leaves(0), scales(0) {}
+
     CascadeInvoker(const PtrStepSzb& _levels, const PtrStepSzb& _octaves, const PtrStepSzf& _stages,
                    const PtrStepSzb& _nodes,  const PtrStepSzf& _leaves)
-    : levels((const Level*)_levels.ptr()), octaves((const Octave*)_octaves.ptr()), stages((const float*)_stages.ptr()),
-       nodes((const Node*)_nodes.ptr()), leaves((const float*)_leaves.ptr())
+    : levels((const Level*)_levels.ptr()),
+      stages((const float*)_stages.ptr()),
+      nodes((const Node*)_nodes.ptr()), leaves((const float*)_leaves.ptr()),
+      scales(_levels.cols / sizeof(Level))
     {}
 
     const Level*  levels;
-    const Octave* octaves;
-
     const float*  stages;
 
     const Node*   nodes;
     const float*  leaves;
 
+    int scales;
+
     void operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
         PtrStepSzi counter, const int downscales, const int csale = -1, const cudaStream_t& stream = 0) const;
+
+    template<bool isUp>
+    __device void detect(Detection* objects, const uint ndetections, uint* ctr, const int downscales) const;
 };
 
 }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index a69be9239..6133bd1cb 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -63,7 +63,7 @@ void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 #include <icf.hpp>
 
 cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale, const int w, const int h)
-:  octave(idx), relScale(scale / oct.scale), shrScale (relScale / (float)oct.shrinkage)
+:  octave(idx), step(oct.stages), relScale(scale / oct.scale)
 {
     workRect.x = round(w / (float)oct.shrinkage);
     workRect.y = round(h / (float)oct.shrinkage);
@@ -100,7 +100,7 @@ namespace imgproc {
 
 struct cv::gpu::SCascade::Fields
 {
-    static Fields* parseCascade(const FileNode &root, const float mins, const float maxs)
+    static Fields* parseCascade(const FileNode &root, const float mins, const float maxs, const int totals)
     {
         static const char *const SC_STAGE_TYPE          = "stageType";
         static const char *const SC_BOOST               = "BOOST";
@@ -119,11 +119,8 @@ struct cv::gpu::SCascade::Fields
         static const char *const SC_ORIG_W              = "width";
         static const char *const SC_ORIG_H              = "height";
 
-        int origWidth = (int)root[SC_ORIG_W];
-        CV_Assert(origWidth  == ORIG_OBJECT_WIDTH);
-
+        int origWidth  = (int)root[SC_ORIG_W];
         int origHeight = (int)root[SC_ORIG_H];
-        CV_Assert(origHeight == ORIG_OBJECT_HEIGHT);
 
         static const char *const SC_OCTAVES             = "octaves";
         static const char *const SC_STAGES              = "stages";
@@ -142,7 +139,6 @@ struct cv::gpu::SCascade::Fields
         static const char * const SC_F_CHANNEL          = "channel";
         static const char * const SC_F_RECT             = "rect";
 
-
         FileNode fn = root[SC_OCTAVES];
             if (fn.empty()) return false;
 
@@ -167,8 +163,8 @@ struct cv::gpu::SCascade::Fields
 
             ushort nstages = saturate_cast<ushort>((int)fns[SC_OCT_STAGES]);
             ushort2 size;
-            size.x = cvRound(ORIG_OBJECT_WIDTH * scale);
-            size.y = cvRound(ORIG_OBJECT_HEIGHT * scale);
+            size.x = cvRound(origWidth * scale);
+            size.y = cvRound(origHeight * scale);
             shrinkage = saturate_cast<ushort>((int)fns[SC_OCT_SHRINKAGE]);
 
             Octave octave(octIndex, nstages, shrinkage, size, scale);
@@ -245,11 +241,11 @@ struct cv::gpu::SCascade::Fields
         CV_Assert(!hleaves.empty());
 
         std::vector<Level> vlevels;
-        float logFactor = (::log(maxs) - ::log(mins)) / (TOTAL_SCALES -1);
+        float logFactor = (::log(maxs) - ::log(mins)) / (totals -1);
 
         float scale = mins;
         int downscales = 0;
-        for (int sc = 0; sc < TOTAL_SCALES; ++sc)
+        for (int sc = 0; sc < totals; ++sc)
         {
             int width  = ::std::max(0.0f, FRAME_WIDTH - (origWidth  * scale));
             int height = ::std::max(0.0f, FRAME_HEIGHT - (origHeight * scale));
@@ -302,7 +298,7 @@ struct cv::gpu::SCascade::Fields
         leaves.upload(hleaves);
         levels.upload(hlevels);
 
-        invoker = device::icf::CascadeInvoker<device::icf::CascadePolicy>(levels, octaves, stages, nodes, leaves);
+        invoker = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, octaves, stages, nodes, leaves);
 
     }
 
@@ -456,16 +452,13 @@ public:
 
     GpuMat sobelBuf;
 
-    device::icf::CascadeInvoker<device::icf::CascadePolicy> invoker;
+    device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker;
 
     enum { BOOST = 0 };
     enum
     {
         FRAME_WIDTH        = 640,
         FRAME_HEIGHT       = 480,
-        TOTAL_SCALES       = 55,
-        ORIG_OBJECT_WIDTH  = 64,
-        ORIG_OBJECT_HEIGHT = 128,
         HOG_BINS           = 6,
         LUV_BINS           = 3,
         HOG_LUV_BINS       = 10
@@ -480,21 +473,19 @@ cv::gpu::SCascade::~SCascade() { delete fields; }
 bool cv::gpu::SCascade::load(const FileNode& fn)
 {
     if (fields) delete fields;
-    fields = Fields::parseCascade(fn, minScale, maxScale);
+    fields = Fields::parseCascade(fn, minScale, maxScale, scales);
     return fields != 0;
 }
 
 void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, Stream& s) const
 {
+    CV_Assert(fields);
+
     const GpuMat colored = image.getGpuMat();
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
     GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
-
-    // we guess user knows about shrincage
-    // CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
-
     Fields& flds = *fields;
 
     if (colored.type() == CV_8UC3)
@@ -518,15 +509,13 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
 void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, const int level, Stream& s) const
 {
+    CV_Assert(fields);
+
     const GpuMat colored = image.getGpuMat();
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
-    // we guess user knows about shrincage
-    // CV_Assert((rois.size().width == getRoiSize().height) && (rois.type() == CV_8UC1));
-
     Fields& flds = *fields;
-
     if (colored.type() == CV_8UC3)
     {
         // only this window size allowed
@@ -549,6 +538,8 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
 void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const
 {
+    CV_Assert(fields);
+
     const GpuMat roi = _roi.getGpuMat();
     _mask.create( roi.cols / 4, roi.rows / 4, roi.type() );
     GpuMat mask = _mask.getGpuMat();
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index cfae940c7..7034b33b9 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -172,7 +172,7 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         sub.setTo(1);
         cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
     }
-
+    objectBoxes.setTo(0);
     cascade.genRoi(rois, trois);
     cascade.detect(colored, trois, objectBoxes);
 
@@ -222,7 +222,7 @@ GPU_TEST_P(SCascadeTestLevel, detect,
 
     cv::gpu::GpuMat trois;
     cascade.genRoi(rois, trois);
-
+    objectBoxes.setTo(0);
     int level = GET_PARAM(3);
     cascade.detect(colored, trois, objectBoxes, level);
 
@@ -281,7 +281,7 @@ GPU_TEST_P(SCascadeTestAll, detect,
 
     cv::gpu::GpuMat trois;
     cascade.genRoi(rois, trois);
-
+    objectBoxes.setTo(0);
     cascade.detect(colored, trois, objectBoxes);
 
     typedef cv::gpu::SCascade::Detection Detection;
@@ -321,7 +321,7 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
 
     cv::gpu::GpuMat trois;
     cascade.genRoi(rois, trois);
-
+    objectBoxes.setTo(0);
     cascade.detect(hogluv, trois, objectBoxes);
 
     typedef cv::gpu::SCascade::Detection Detection;
@@ -357,7 +357,7 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
 
     cv::gpu::GpuMat trois;
     cascade.genRoi(rois, trois, s);
-
+    objectBoxes.setTo(0);
     cascade.detect(colored, trois, objectBoxes, s);
 
     cudaDeviceSynchronize();

From 08910e81af95dd2004930845e5f206c2b9368aac Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 12:40:44 +0400
Subject: [PATCH 067/155] integrate pre-Kepler architectures

---
 modules/gpu/src/cuda/isf-sc.cu  | 15 +++++++++++++++
 modules/gpu/src/softcascade.cpp | 16 +++++++++++-----
 2 files changed, 26 insertions(+), 5 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index ac4b8f0e8..b6c87e17b 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -209,6 +209,7 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
         const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
         float impact = leaves[(st + threadIdx.x) * 4 + lShift];
 
+#if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
 #pragma unroll
         // scan on shuffl functions
         for (int i = 1; i < Policy::WARP; i *= 2)
@@ -218,7 +219,21 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
             if (threadIdx.x >= i)
                 impact += n;
         }
+#else
+        __shared__ volatile float ptr[Policy::STA_X * Policy::STA_Y];
 
+        const int idx = threadIdx.y * Policy::STA_X + threadIdx.x;
+
+        ptr[idx] = impact;
+
+        if ( threadIdx.x >=  1) ptr [idx ] = (ptr [idx -  1] + ptr [idx]);
+        if ( threadIdx.x >=  2) ptr [idx ] = (ptr [idx -  2] + ptr [idx]);
+        if ( threadIdx.x >=  4) ptr [idx ] = (ptr [idx -  4] + ptr [idx]);
+        if ( threadIdx.x >=  8) ptr [idx ] = (ptr [idx -  8] + ptr [idx]);
+        if ( threadIdx.x >= 16) ptr [idx ] = (ptr [idx - 16] + ptr [idx]);
+
+        impact = ptr[idx];
+#endif
         confidence += impact;
         if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
     }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 6133bd1cb..c5bcbedb5 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -298,14 +298,14 @@ struct cv::gpu::SCascade::Fields
         leaves.upload(hleaves);
         levels.upload(hlevels);
 
-        invoker = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, octaves, stages, nodes, leaves);
-
     }
 
     void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
     {
         cudaMemset(count.data, 0, sizeof(Detection));
         cudaSafeCall( cudaGetLastError());
+        device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker
+        = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, octaves, stages, nodes, leaves);
         invoker(roi, hogluv, objects, count, downscales, scale, stream);
     }
 
@@ -407,8 +407,14 @@ private:
 
         GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
         cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA, s);
-        cudaStream_t stream = StreamAccessor::getStream(s);
-        device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, stream);
+
+        if (info.majorVersion() < 3)
+            cv::gpu::integralBuffered(shrunk, hogluv, integralBuffer, s);
+        else
+        {
+            cudaStream_t stream = StreamAccessor::getStream(s);
+            device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, stream);
+        }
     }
 
 public:
@@ -452,7 +458,7 @@ public:
 
     GpuMat sobelBuf;
 
-    device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker;
+    DeviceInfo info;
 
     enum { BOOST = 0 };
     enum

From 72e2b8b370c10024adb05a46230fbac782fbeee4 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 14:00:02 +0400
Subject: [PATCH 068/155] remove size constraints of input frame

---
 modules/gpu/src/cuda/isf-sc.cu  |  4 +-
 modules/gpu/src/softcascade.cpp | 97 ++++++++++++++++++---------------
 2 files changed, 56 insertions(+), 45 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index b6c87e17b..7f7a10e92 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -256,8 +256,8 @@ template<typename Policy>
 void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
     PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const
 {
-    int fw = 160;
-    int fh = 120;
+    int fw = roi.rows;
+    int fh = roi.cols;
 
     dim3 grid(fw, fh / Policy::STA_Y, (scale == -1) ? downscales : 1);
 
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index c5bcbedb5..ad6e00027 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -240,15 +240,26 @@ struct cv::gpu::SCascade::Fields
         cv::Mat hleaves(cv::Mat(vleaves).reshape(1,1));
         CV_Assert(!hleaves.empty());
 
-        std::vector<Level> vlevels;
-        float logFactor = (::log(maxs) - ::log(mins)) / (totals -1);
+        Fields* fields = new Fields(mins, maxs, totals, origWidth, origHeight, shrinkage, 0,
+            hoctaves, hstages, hnodes, hleaves);
+        fields->voctaves = voctaves;
+        fields->createLevels(FRAME_HEIGHT, FRAME_WIDTH);
 
-        float scale = mins;
-        int downscales = 0;
+        return fields;
+    }
+
+    int createLevels(const int fh, const int fw)
+    {
+        using namespace device::icf;
+        std::vector<Level> vlevels;
+        float logFactor = (::log(maxScale) - ::log(minScale)) / (totals -1);
+
+        float scale = minScale;
+        int dcs = 0;
         for (int sc = 0; sc < totals; ++sc)
         {
-            int width  = ::std::max(0.0f, FRAME_WIDTH - (origWidth  * scale));
-            int height = ::std::max(0.0f, FRAME_HEIGHT - (origHeight * scale));
+            int width  = ::std::max(0.0f, fw - (origObjWidth  * scale));
+            int height = ::std::max(0.0f, fh - (origObjHeight * scale));
 
             float logScale = ::log(scale);
             int fit = fitOctave(voctaves, logScale);
@@ -260,44 +271,44 @@ struct cv::gpu::SCascade::Fields
             else
             {
                 vlevels.push_back(level);
-                if (voctaves[fit].scale < 1) ++downscales;
+                if (voctaves[fit].scale < 1) ++dcs;
             }
 
-            if (::fabs(scale - maxs) < FLT_EPSILON) break;
-            scale = ::std::min(maxs, ::expf(::log(scale) + logFactor));
+            if (::fabs(scale - maxScale) < FLT_EPSILON) break;
+            scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
         }
 
-        cv::Mat hlevels(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );
+        cv::Mat hlevels = cv::Mat(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );
         CV_Assert(!hlevels.empty());
-
-        Fields* fields = new Fields(mins, maxs, origWidth, origHeight, shrinkage, downscales,
-            hoctaves, hstages, hnodes, hleaves, hlevels);
-
-        return fields;
+        levels.upload(hlevels);
+        downscales = dcs;
+        return dcs;
     }
 
-    Fields( const float mins, const float maxs, const int ow, const int oh, const int shr, const int ds,
-        cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves, cv::Mat hlevels)
-    : minScale(mins), maxScale(maxs), origObjWidth(ow), origObjHeight(oh), shrinkage(shr), downscales(ds)
+    bool update(int fh, int fw, int shr)
     {
-        plane.create(FRAME_HEIGHT * (HOG_LUV_BINS + 1), FRAME_WIDTH, CV_8UC1);
-        fplane.create(FRAME_HEIGHT * 6, FRAME_WIDTH, CV_32FC1);
-        luv.create(FRAME_HEIGHT, FRAME_WIDTH, CV_8UC3);
+        if (fh == luv.rows && fh == luv.cols) return false;
+        plane.create(fh * (HOG_LUV_BINS + 1), fw, CV_8UC1);
+        fplane.create(fh * HOG_BINS, fw, CV_32FC1);
+        luv.create(fh, fw, CV_8UC3);
 
-        shrunk.create(FRAME_HEIGHT / shr * HOG_LUV_BINS, FRAME_WIDTH / shr, CV_8UC1);
+        shrunk.create(fh / shr * HOG_LUV_BINS, fw / shr, CV_8UC1);
         integralBuffer.create(shrunk.rows, shrunk.cols, CV_32SC1);
 
-        hogluv.create((FRAME_HEIGHT / shr) * HOG_LUV_BINS + 1, FRAME_WIDTH / shr + 1, CV_32SC1);
+        hogluv.create((fh / shr) * HOG_LUV_BINS + 1, fw / shr + 1, CV_32SC1);
         hogluv.setTo(cv::Scalar::all(0));
+        return true;
+    }
 
-        detCounter.create(sizeof(Detection) / sizeof(int),1, CV_32SC1);
-
+    Fields( const float mins, const float maxs, const int tts, const int ow, const int oh, const int shr, const int ds,
+        cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves)
+    : minScale(mins), maxScale(maxs), totals(tts), origObjWidth(ow), origObjHeight(oh), shrinkage(shr), downscales(ds)
+    {
+        update(FRAME_HEIGHT, FRAME_WIDTH, shr);
         octaves.upload(hoctaves);
         stages.upload(hstages);
         nodes.upload(hnodes);
         leaves.upload(hleaves);
-        levels.upload(hlevels);
-
     }
 
     void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
@@ -316,8 +327,8 @@ struct cv::gpu::SCascade::Fields
         else
             cudaMemset(plane.data, 0, plane.step * plane.rows);
 
-        static const int fw = Fields::FRAME_WIDTH;
-        static const int fh = Fields::FRAME_HEIGHT;
+        const int fw = colored.cols;
+        const int fh = colored.rows;
 
         GpuMat gray(plane, cv::Rect(0, fh * Fields::HOG_LUV_BINS, fw, fh));
         cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY, s);
@@ -325,7 +336,7 @@ struct cv::gpu::SCascade::Fields
 
         createLuvBins(colored, s);
 
-        integrate(s);
+        integrate(fh, fw, s);
     }
 
 private:
@@ -352,8 +363,8 @@ private:
 
     void createHogBins(const cv::gpu::GpuMat& gray, Stream& s)
     {
-        static const int fw = Fields::FRAME_WIDTH;
-        static const int fh = Fields::FRAME_HEIGHT;
+        static const int fw = gray.cols;
+        static const int fh = gray.rows;
 
         GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
         GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
@@ -386,8 +397,8 @@ private:
 
     void createLuvBins(const cv::gpu::GpuMat& colored, Stream& s)
     {
-        static const int fw = Fields::FRAME_WIDTH;
-        static const int fh = Fields::FRAME_HEIGHT;
+        static const int fw = colored.cols;
+        static const int fh = colored.rows;
 
         cv::gpu::cvtColor(colored, luv, CV_BGR2Luv, s);
 
@@ -400,11 +411,8 @@ private:
         cv::gpu::split(luv, splited, s);
     }
 
-    void integrate( Stream& s)
+    void integrate(const int fh, const int fw, Stream& s)
     {
-        int fw = Fields::FRAME_WIDTH;
-        int fh = Fields::FRAME_HEIGHT;
-
         GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
         cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA, s);
 
@@ -423,6 +431,8 @@ public:
     float minScale;
     float maxScale;
 
+    int totals;
+
     int origObjWidth;
     int origObjHeight;
 
@@ -447,8 +457,6 @@ public:
     // 161x121x10
     GpuMat hogluv;
 
-    GpuMat detCounter;
-
     // Cascade from xml
     GpuMat octaves;
     GpuMat stages;
@@ -458,6 +466,8 @@ public:
 
     GpuMat sobelBuf;
 
+    std::vector<device::icf::Octave> voctaves;
+
     DeviceInfo info;
 
     enum { BOOST = 0 };
@@ -488,6 +498,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     CV_Assert(fields);
 
     const GpuMat colored = image.getGpuMat();
+
     // only color images are supperted
     CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
 
@@ -496,8 +507,8 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
     if (colored.type() == CV_8UC3)
     {
-        // only this window size allowed
-        CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
+        if (!flds.update(colored.rows, colored.cols, flds.shrinkage))
+            flds.createLevels(colored.rows, colored.cols);
         flds.preprocess(colored, s);
     }
     else
@@ -525,7 +536,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     if (colored.type() == CV_8UC3)
     {
         // only this window size allowed
-        CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
+        // CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
         flds.preprocess(colored, s);
     }
     else

From 8acfbde68e5b9c4bd6640a21c384c3fff8fd28aa Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 14:21:22 +0400
Subject: [PATCH 069/155] remove debug detect at scale method

---
 modules/gpu/doc/object_detection.rst    |  4 --
 modules/gpu/include/opencv2/gpu/gpu.hpp |  2 -
 modules/gpu/src/cuda/isf-sc.cu          | 37 +++---------
 modules/gpu/src/icf.hpp                 |  5 +-
 modules/gpu/src/softcascade.cpp         | 35 +-----------
 modules/gpu/test/test_softcascade.cpp   | 76 ++++++++++++-------------
 6 files changed, 53 insertions(+), 106 deletions(-)

diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst
index 64348717c..c503d93fe 100644
--- a/modules/gpu/doc/object_detection.rst
+++ b/modules/gpu/doc/object_detection.rst
@@ -248,7 +248,6 @@ Implementation of soft (stageless) cascaded detector. ::
         virtual ~SCascade();
         virtual bool load(const FileNode& fn);
         virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
-        virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
         void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
     };
 
@@ -292,7 +291,6 @@ SCascade::detect
 Apply cascade to an input frame and return the vector of Decection objcts.
 
 .. ocv:function:: void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const
-.. ocv:function:: void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const
 
     :param image: a frame on which detector will be applied.
 
@@ -302,8 +300,6 @@ Apply cascade to an input frame and return the vector of Decection objcts.
 
     :param stream: a high-level CUDA stream abstraction used for asynchronous execution.
 
-    :param level: used for execution cascade on specific scales pyramid level.
-
 
 SCascade::genRoi
 --------------------------
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 9a43760f9..db228a69b 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1577,9 +1577,7 @@ public:
     // Param objects is an output array of Detections represented as GpuMat of detections (SCascade::Detection)
     //    The first element of the matrix is  actually a count of detections.
     // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
-    // Param level used for execution cascade on specific scales pyramid level.
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
-    virtual void detect(InputArray image, InputArray rois, OutputArray objects, const int level, Stream& stream = Stream::Null()) const;
 
     // Convert ROI matrix into the suitable for detect method.
     // Param roi is an input matrix of the same size as the image.
diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 7f7a10e92..3d3536683 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -45,15 +45,6 @@
 #include <stdio.h>
 #include <float.h>
 
-// #define LOG_CUDA_CASCADE
-
-#if defined LOG_CUDA_CASCADE
-# define dprintf(format, ...) \
-            do { printf(format, __VA_ARGS__); } while (0)
-#else
-# define dprintf(format, ...)
-#endif
-
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
@@ -254,12 +245,12 @@ __global__ void soft_cascade(const CascadeInvoker<Policy> invoker, Detection* ob
 
 template<typename Policy>
 void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const
+    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const cudaStream_t& stream) const
 {
     int fw = roi.rows;
     int fh = roi.cols;
 
-    dim3 grid(fw, fh / Policy::STA_Y, (scale == -1) ? downscales : 1);
+    dim3 grid(fw, fh / Policy::STA_Y, downscales);
 
     uint* ctr = (uint*)(counter.ptr(0));
     Detection* det = (Detection*)objects.ptr();
@@ -268,26 +259,16 @@ void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi&
     cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
     cudaSafeCall( cudaBindTexture2D(0, thogluv, hogluv.data, desc, hogluv.cols, hogluv.rows, hogluv.step));
 
-    cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<float2>();
-    cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / 8, roi.rows, roi.step));
+    cudaChannelFormatDesc desc_roi = cudaCreateChannelDesc<typename Policy::roi_type>();
+    cudaSafeCall( cudaBindTexture2D(0, troi, roi.data, desc_roi, roi.cols / Policy::STA_Y, roi.rows, roi.step));
 
     const CascadeInvoker<Policy> inv = *this;
 
-    if (scale == -1)
-    {
-        soft_cascade<Policy, false><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, 0);
-        cudaSafeCall( cudaGetLastError());
+    soft_cascade<Policy, false><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, 0);
+    cudaSafeCall( cudaGetLastError());
 
-        grid = dim3(fw, fh / Policy::STA_Y, scales - downscales);
-        soft_cascade<Policy, true><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, downscales);
-    }
-    else
-    {
-        if (scale >= downscales)
-            soft_cascade<Policy, true><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, scale);
-        else
-            soft_cascade<Policy, false><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, scale);
-    }
+    grid = dim3(fw, fh / Policy::STA_Y, scales - downscales);
+    soft_cascade<Policy, true><<<grid, Policy::block(), 0, stream>>>(inv, det, max_det, ctr, downscales);
 
     if (!stream)
     {
@@ -297,7 +278,7 @@ void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi&
 }
 
 template void CascadeInvoker<GK107PolicyX4>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const int scale, const cudaStream_t& stream) const;
+    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const cudaStream_t& stream) const;
 
 }
 }}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 8eb080e23..2bbbb64d2 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -118,9 +118,10 @@ struct __align__(16) Detection
 struct GK107PolicyX4
 {
     enum {WARP = 32, STA_X = WARP, STA_Y = 8, SHRINKAGE = 4};
+    typedef float2 roi_type;
     static const dim3 block()
     {
-        return dim3(GK107PolicyX4::STA_X, GK107PolicyX4::STA_Y);
+        return dim3(STA_X, STA_Y);
     }
 };
 
@@ -146,7 +147,7 @@ struct CascadeInvoker
     int scales;
 
     void operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales, const int csale = -1, const cudaStream_t& stream = 0) const;
+        PtrStepSzi counter, const int downscales, const cudaStream_t& stream = 0) const;
 
     template<bool isUp>
     __device void detect(Detection* objects, const uint ndetections, uint* ctr, const int downscales) const;
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index ad6e00027..5da3abf53 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -311,13 +311,13 @@ struct cv::gpu::SCascade::Fields
         leaves.upload(hleaves);
     }
 
-    void detect(int scale, const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
+    void detect(const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
     {
         cudaMemset(count.data, 0, sizeof(Detection));
         cudaSafeCall( cudaGetLastError());
         device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker
         = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, octaves, stages, nodes, leaves);
-        invoker(roi, hogluv, objects, count, downscales, scale, stream);
+        invoker(roi, hogluv, objects, count, downscales, stream);
     }
 
     void preprocess(const cv::gpu::GpuMat& colored, Stream& s)
@@ -521,36 +521,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    flds.detect(-1, rois, tmp, objects, stream);
-}
-
-void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, const int level, Stream& s) const
-{
-    CV_Assert(fields);
-
-    const GpuMat colored = image.getGpuMat();
-    // only color images are supperted
-    CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
-
-    Fields& flds = *fields;
-    if (colored.type() == CV_8UC3)
-    {
-        // only this window size allowed
-        // CV_Assert(colored.cols == Fields::FRAME_WIDTH && colored.rows == Fields::FRAME_HEIGHT);
-        flds.preprocess(colored, s);
-    }
-    else
-    {
-        colored.copyTo(flds.hogluv);
-    }
-
-    GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
-
-    GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
-    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
-    cudaStream_t stream = StreamAccessor::getStream(s);
-
-    flds.detect(level, rois, tmp, objects, stream);
+    flds.detect(rois, tmp, objects, stream);
 }
 
 void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 7034b33b9..e36c28904 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -195,55 +195,55 @@ GPU_TEST_P(SCascadeTestRoi, detect,
 
 }
 
-typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestLevel;
-GPU_TEST_P(SCascadeTestLevel, detect,
-        testing::Combine(
-        ALL_DEVICES,
-        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-        testing::Range(0, 47)
-        ))
-{
-    cv::gpu::setDevice(GET_PARAM(0).deviceID());
+// typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestLevel;
+// GPU_TEST_P(SCascadeTestLevel, detect,
+//         testing::Combine(
+//         ALL_DEVICES,
+//         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+//         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+//         testing::Range(0, 47)
+//         ))
+// {
+//     cv::gpu::setDevice(GET_PARAM(0).deviceID());
 
-    cv::gpu::SCascade cascade;
+//     cv::gpu::SCascade cascade;
 
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+//     cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+//     ASSERT_TRUE(fs.isOpened());
 
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+//     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
-    ASSERT_FALSE(coloredCpu.empty());
+//     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
+//     ASSERT_FALSE(coloredCpu.empty());
 
-    typedef cv::gpu::SCascade::Detection Detection;
-    GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(1);
+//     typedef cv::gpu::SCascade::Detection Detection;
+//     GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+//     rois.setTo(1);
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois);
-    objectBoxes.setTo(0);
-    int level = GET_PARAM(3);
-    cascade.detect(colored, trois, objectBoxes, level);
+//     cv::gpu::GpuMat trois;
+//     cascade.genRoi(rois, trois);
+//     objectBoxes.setTo(0);
+//     int level = GET_PARAM(3);
+//     cascade.detect(colored, trois, objectBoxes, level);
 
-    cv::Mat dt(objectBoxes);
+//     cv::Mat dt(objectBoxes);
 
-    Detection* dts = ((Detection*)dt.data) + 1;
-    int* count = dt.ptr<int>(0);
+//     Detection* dts = ((Detection*)dt.data) + 1;
+//     int* count = dt.ptr<int>(0);
 
-    cv::Mat result(coloredCpu);
+//     cv::Mat result(coloredCpu);
 
-    printTotal(std::cout, *count);
-    for (int i = 0; i  < *count; ++i)
-    {
-        Detection d = dts[i];
-        print(std::cout, d);
-        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
-    }
+//     printTotal(std::cout, *count);
+//     for (int i = 0; i  < *count; ++i)
+//     {
+//         Detection d = dts[i];
+//         print(std::cout, d);
+//         cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+//     }
 
-    writeResult(result, level);
-    SHOW(result);
-}
+//     writeResult(result, level);
+//     SHOW(result);
+// }
 
 TEST(SCascadeTest, readCascade)
 {

From a30bbda3bddfa55c1e6261e1d872c262f69deb43 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 14:36:59 +0400
Subject: [PATCH 070/155] remove hardcoded values

---
 modules/gpu/src/cuda/isf-sc.cu  |  5 +++--
 modules/gpu/src/icf.hpp         |  2 +-
 modules/gpu/src/softcascade.cpp | 11 ++++++-----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index 3d3536683..a4496bf67 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -181,6 +181,7 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
     int st = level.octave * level.step;
     const int stEnd = st + level.step;
 
+    const int hogluvStep = gridDim.y * Policy::STA_Y;
     float confidence = 0.f;
     for(; st < stEnd; st += Policy::WARP)
     {
@@ -189,13 +190,13 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
         Node node = nodes[nId];
 
         float threshold = rescale<isUp>(level, node);
-        int sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
+        int sum = get<isUp>(x, y + (node.threshold >> 28) * hogluvStep, node.rect);
 
         int next = 1 + (int)(sum >= threshold);
 
         node = nodes[nId + next];
         threshold = rescale<isUp>(level, node);
-        sum = get<isUp>(x, y + (node.threshold >> 28) * 120, node.rect);
+        sum = get<isUp>(x, y + (node.threshold >> 28) * hogluvStep, node.rect);
 
         const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
         float impact = leaves[(st + threadIdx.x) * 4 + lShift];
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 2bbbb64d2..454ac30da 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -130,7 +130,7 @@ struct CascadeInvoker
 {
     CascadeInvoker(): levels(0), stages(0), nodes(0), leaves(0), scales(0) {}
 
-    CascadeInvoker(const PtrStepSzb& _levels, const PtrStepSzb& _octaves, const PtrStepSzf& _stages,
+    CascadeInvoker(const PtrStepSzb& _levels, const PtrStepSzf& _stages,
                    const PtrStepSzb& _nodes,  const PtrStepSzf& _leaves)
     : levels((const Level*)_levels.ptr()),
       stages((const float*)_stages.ptr()),
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 5da3abf53..038654225 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -316,7 +316,7 @@ struct cv::gpu::SCascade::Fields
         cudaMemset(count.data, 0, sizeof(Detection));
         cudaSafeCall( cudaGetLastError());
         device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker
-        = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, octaves, stages, nodes, leaves);
+        = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, stages, nodes, leaves);
         invoker(roi, hogluv, objects, count, downscales, stream);
     }
 
@@ -414,7 +414,7 @@ private:
     void integrate(const int fh, const int fw, Stream& s)
     {
         GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
-        cv::gpu::resize(channels, shrunk, cv::Size(), 0.25, 0.25, CV_INTER_AREA, s);
+        cv::gpu::resize(channels, shrunk, cv::Size(), 1.f / shrinkage, 1.f / shrinkage, CV_INTER_AREA, s);
 
         if (info.majorVersion() < 3)
             cv::gpu::integralBuffered(shrunk, hogluv, integralBuffer, s);
@@ -518,7 +518,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
 
     GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
-    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols -  sizeof(Detection), 1));
+    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols - sizeof(Detection), 1));
     cudaStream_t stream = StreamAccessor::getStream(s);
 
     flds.detect(rois, tmp, objects, stream);
@@ -527,13 +527,14 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const
 {
     CV_Assert(fields);
+    int shr = (*fields).shrinkage;
 
     const GpuMat roi = _roi.getGpuMat();
-    _mask.create( roi.cols / 4, roi.rows / 4, roi.type() );
+    _mask.create( roi.cols / shr, roi.rows / shr, roi.type() );
     GpuMat mask = _mask.getGpuMat();
     cv::gpu::GpuMat tmp;
 
-    cv::gpu::resize(roi, tmp, cv::Size(), 0.25, 0.25, CV_INTER_AREA, stream);
+    cv::gpu::resize(roi, tmp, cv::Size(), 1.f / shr, 1.f / shr, CV_INTER_AREA, stream);
     cv::gpu::transpose(tmp, mask, stream);
 }
 

From 781c04324eab9537dc3ddb0b01f75975990b8e14 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 14:47:00 +0400
Subject: [PATCH 071/155] refactor: PrefixSum

---
 modules/gpu/src/cuda/isf-sc.cu | 60 ++++++++++++++++++++--------------
 1 file changed, 35 insertions(+), 25 deletions(-)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/isf-sc.cu
index a4496bf67..27d60e637 100644
--- a/modules/gpu/src/cuda/isf-sc.cu
+++ b/modules/gpu/src/cuda/isf-sc.cu
@@ -79,6 +79,39 @@ namespace icf {
         }
     }
 
+    template<typename Policy>
+    struct PrefixSum
+    {
+    __device static void apply(float& impact)
+        {
+    #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
+    #pragma unroll
+            // scan on shuffl functions
+            for (int i = 1; i < Policy::WARP; i *= 2)
+            {
+                const float n = __shfl_up(impact, i, Policy::WARP);
+
+                if (threadIdx.x >= i)
+                    impact += n;
+            }
+    #else
+            __shared__ volatile float ptr[Policy::STA_X * Policy::STA_Y];
+
+            const int idx = threadIdx.y * Policy::STA_X + threadIdx.x;
+
+            ptr[idx] = impact;
+
+            if ( threadIdx.x >=  1) ptr [idx ] = (ptr [idx -  1] + ptr [idx]);
+            if ( threadIdx.x >=  2) ptr [idx ] = (ptr [idx -  2] + ptr [idx]);
+            if ( threadIdx.x >=  4) ptr [idx ] = (ptr [idx -  4] + ptr [idx]);
+            if ( threadIdx.x >=  8) ptr [idx ] = (ptr [idx -  8] + ptr [idx]);
+            if ( threadIdx.x >= 16) ptr [idx ] = (ptr [idx - 16] + ptr [idx]);
+
+            impact = ptr[idx];
+    #endif
+        }
+    };
+
     texture<int,  cudaTextureType2D, cudaReadModeElementType> thogluv;
 
     template<bool isUp>
@@ -201,32 +234,9 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
         const int lShift = (next - 1) * 2 + (int)(sum >= threshold);
         float impact = leaves[(st + threadIdx.x) * 4 + lShift];
 
-#if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 300
-#pragma unroll
-        // scan on shuffl functions
-        for (int i = 1; i < Policy::WARP; i *= 2)
-        {
-            const float n = __shfl_up(impact, i, Policy::WARP);
-
-            if (threadIdx.x >= i)
-                impact += n;
-        }
-#else
-        __shared__ volatile float ptr[Policy::STA_X * Policy::STA_Y];
-
-        const int idx = threadIdx.y * Policy::STA_X + threadIdx.x;
-
-        ptr[idx] = impact;
-
-        if ( threadIdx.x >=  1) ptr [idx ] = (ptr [idx -  1] + ptr [idx]);
-        if ( threadIdx.x >=  2) ptr [idx ] = (ptr [idx -  2] + ptr [idx]);
-        if ( threadIdx.x >=  4) ptr [idx ] = (ptr [idx -  4] + ptr [idx]);
-        if ( threadIdx.x >=  8) ptr [idx ] = (ptr [idx -  8] + ptr [idx]);
-        if ( threadIdx.x >= 16) ptr [idx ] = (ptr [idx - 16] + ptr [idx]);
-
-        impact = ptr[idx];
-#endif
+        PrefixSum<Policy>::apply(impact);
         confidence += impact;
+
         if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
     }
 

From ee4f003e725cea21690d361f03c2596304d28720 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 14:49:38 +0400
Subject: [PATCH 072/155] fixed typo

---
 modules/gpu/src/cuda/{isf-sc.cu => icf-sc.cu} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename modules/gpu/src/cuda/{isf-sc.cu => icf-sc.cu} (100%)

diff --git a/modules/gpu/src/cuda/isf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
similarity index 100%
rename from modules/gpu/src/cuda/isf-sc.cu
rename to modules/gpu/src/cuda/icf-sc.cu

From c3e4a52fbe44ae5bf2f754e922a2e932e3d20a28 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 20:11:18 +0400
Subject: [PATCH 073/155] soft cascade sample

---
 modules/gpu/src/softcascade.cpp |   4 +-
 samples/gpu/softcascade.cpp     | 106 ++++++++++++++++++++++++++++++++
 2 files changed, 109 insertions(+), 1 deletion(-)
 create mode 100644 samples/gpu/softcascade.cpp

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 038654225..7f5221f37 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -287,7 +287,8 @@ struct cv::gpu::SCascade::Fields
 
     bool update(int fh, int fw, int shr)
     {
-        if (fh == luv.rows && fh == luv.cols) return false;
+        if ((fh == luv.rows) && (fw == luv.cols)) return false;
+
         plane.create(fh * (HOG_LUV_BINS + 1), fw, CV_8UC1);
         fplane.create(fh * HOG_BINS, fw, CV_32FC1);
         luv.create(fh, fw, CV_8UC3);
@@ -297,6 +298,7 @@ struct cv::gpu::SCascade::Fields
 
         hogluv.create((fh / shr) * HOG_LUV_BINS + 1, fw / shr + 1, CV_32SC1);
         hogluv.setTo(cv::Scalar::all(0));
+
         return true;
     }
 
diff --git a/samples/gpu/softcascade.cpp b/samples/gpu/softcascade.cpp
new file mode 100644
index 000000000..3c08fdb1c
--- /dev/null
+++ b/samples/gpu/softcascade.cpp
@@ -0,0 +1,106 @@
+#include <opencv2/gpu/gpu.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <iostream>
+
+int main(int argc, char** argv)
+{
+    const std::string keys =
+        "{help h usage ?    |     | print this message }"
+        "{cascade c         |     | path to configuration xml }"
+        "{frames f          |     | path to configuration xml }"
+        "{min_scale         |0.4f | path to configuration xml }"
+        "{max_scale         |5.0f | path to configuration xml }"
+        "{total_scales      |55   | path to configuration xml }"
+        "{device d          |0    | path to configuration xml }"
+    ;
+
+    cv::CommandLineParser parser(argc, argv, keys);
+    parser.about("Soft cascade training application.");
+
+    if (parser.has("help"))
+    {
+        parser.printMessage();
+        return 0;
+    }
+
+    if (!parser.check())
+    {
+        parser.printErrors();
+        return 1;
+    }
+
+    cv::gpu::setDevice(parser.get<int>("device"));
+
+    std::string cascadePath = parser.get<std::string>("cascade");
+
+    cv::FileStorage fs(cascadePath, cv::FileStorage::READ);
+    if(!fs.isOpened())
+    {
+        std::cout << "Soft Cascade file " << cascadePath << " can't be opened." << std::endl << std::flush;
+        return 1;
+    }
+
+    std::cout << "Read cascade from file " << cascadePath << std::endl;
+
+    float minScale =  parser.get<float>("min_scale");
+    float maxScale =  parser.get<float>("max_scale");
+    int scales     =  parser.get<int>("total_scales");
+
+    using cv::gpu::SCascade;
+    SCascade cascade(minScale, maxScale, scales);
+
+    if (!cascade.load(fs.getFirstTopLevelNode()))
+    {
+        std::cout << "Soft Cascade can't be parsed." << std::endl << std::flush;
+        return 1;
+    }
+
+    std::string frames = parser.get<std::string>("frames");
+    cv::VideoCapture capture(frames);
+    if(!capture.isOpened())
+    {
+        std::cout << "Frame source " << frames << " can't be opened." << std::endl << std::flush;
+        return 1;
+    }
+
+    cv::gpu::GpuMat objects(1, sizeof(SCascade::Detection) * 10000, CV_8UC1);
+    cv::gpu::printShortCudaDeviceInfo(parser.get<int>("device"));
+    for (;;)
+    {
+        cv::Mat frame;
+        if (!capture.read(frame))
+        {
+            std::cout << "Nothing to read. " << std::endl << std::flush;
+            return 0;
+        }
+
+        cv::gpu::GpuMat dframe(frame), roi(frame.rows, frame.cols, CV_8UC1), trois;
+        roi.setTo(cv::Scalar::all(1));
+        cascade.genRoi(roi, trois);
+        cascade.detect(dframe, trois, objects);
+
+        cv::Mat dt(objects);
+        typedef cv::gpu::SCascade::Detection Detection;
+
+        Detection* dts = ((Detection*)dt.data) + 1;
+        int* count = dt.ptr<int>(0);
+
+        std::cout << *count << std::endl;
+
+        cv::Mat result;
+        frame.copyTo(result);
+
+
+        for (int i = 0; i < *count; ++i)
+        {
+            Detection d = dts[i];
+            cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+        }
+
+        std::cout << "working..." << std::endl;
+        cv::imshow("Soft Cascade demo", result);
+        cv::waitKey(10);
+    }
+
+    return 0;
+}
\ No newline at end of file

From 0865227049b465bc61dc104627dbbf50611f3436 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 20:28:08 +0400
Subject: [PATCH 074/155] check if scaling values changed

---
 modules/gpu/src/softcascade.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 7f5221f37..bf543150b 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -248,6 +248,17 @@ struct cv::gpu::SCascade::Fields
         return fields;
     }
 
+    bool check(float mins,float  maxs, int scales)
+    {
+        bool updated = (minScale == mins) || (maxScale == maxs) || (totals = scales);
+
+        minScale = mins;
+        maxScale = maxScale;
+        totals   = scales;
+
+        return updated;
+    }
+
     int createLevels(const int fh, const int fw)
     {
         using namespace device::icf;
@@ -509,7 +520,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
     if (colored.type() == CV_8UC3)
     {
-        if (!flds.update(colored.rows, colored.cols, flds.shrinkage))
+        if (!flds.update(colored.rows, colored.cols, flds.shrinkage) || flds.check(minScale, maxScale, scales))
             flds.createLevels(colored.rows, colored.cols);
         flds.preprocess(colored, s);
     }

From a9f10e5cadeb64bf956e5bef624a494bf65142ce Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 14 Nov 2012 20:34:17 +0400
Subject: [PATCH 075/155] fixed compile without cuda

---
 modules/gpu/src/softcascade.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index bf543150b..d5a8e8481 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -52,7 +52,6 @@ cv::gpu::SCascade::~SCascade() { throw_nogpu(); }
 bool cv::gpu::SCascade::load(const FileNode&) { throw_nogpu(); return false;}
 
 void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, Stream&) const { throw_nogpu(); }
-void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, const int, Stream&) const { throw_nogpu(); }
 
 void cv::gpu::SCascade::genRoi(InputArray, OutputArray, Stream&) const { throw_nogpu(); }
 

From d47c112434064c90816af2cf993e1ede3b303a7a Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 12:18:31 +0400
Subject: [PATCH 076/155] fix abs_func and minimum/maximum functors

---
 .../include/opencv2/gpu/device/functional.hpp | 89 +++++++++++++++++--
 .../include/opencv2/gpu/device/vec_math.hpp   |  4 +-
 modules/gpu/src/cuda/pyrlk.cu                 |  4 +-
 modules/gpu/src/cuda/surf.cu                  |  4 +-
 4 files changed, 86 insertions(+), 15 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/functional.hpp b/modules/gpu/include/opencv2/gpu/device/functional.hpp
index c601cf527..6e0471e9a 100644
--- a/modules/gpu/include/opencv2/gpu/device/functional.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/functional.hpp
@@ -302,18 +302,18 @@ namespace cv { namespace gpu { namespace device
     template <> struct name<type> : binary_function<type, type, type> \
     { \
         __device__ __forceinline__ type operator()(type lhs, type rhs) const {return op(lhs, rhs);} \
-        __device__ __forceinline__ name(const name& other):binary_function<type, type, type>(){}\
-        __device__ __forceinline__ name():binary_function<type, type, type>(){}\
+        __device__ __forceinline__ name() {}\
+        __device__ __forceinline__ name(const name&) {}\
     };
 
     template <typename T> struct maximum : binary_function<T, T, T>
     {
         __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType lhs, typename TypeTraits<T>::ParameterType rhs) const
         {
-            return lhs < rhs ? rhs : lhs;
+            return max(lhs, rhs);
         }
-        __device__ __forceinline__ maximum(const maximum& other):binary_function<T, T, T>(){}
-        __device__ __forceinline__ maximum():binary_function<T, T, T>(){}
+        __device__ __forceinline__ maximum() {}
+        __device__ __forceinline__ maximum(const maximum&) {}
     };
 
     OPENCV_GPU_IMPLEMENT_MINMAX(maximum, uchar, ::max)
@@ -330,10 +330,10 @@ namespace cv { namespace gpu { namespace device
     {
         __device__ __forceinline__ T operator()(typename TypeTraits<T>::ParameterType lhs, typename TypeTraits<T>::ParameterType rhs) const
         {
-            return lhs < rhs ? lhs : rhs;
+            return min(lhs, rhs);
         }
-        __device__ __forceinline__ minimum(const minimum& other):binary_function<T, T, T>(){}
-        __device__ __forceinline__ minimum():binary_function<T, T, T>(){}
+        __device__ __forceinline__ minimum() {}
+        __device__ __forceinline__ minimum(const minimum&) {}
     };
 
     OPENCV_GPU_IMPLEMENT_MINMAX(minimum, uchar, ::min)
@@ -350,6 +350,78 @@ namespace cv { namespace gpu { namespace device
 
     // Math functions
 ///bound=========================================
+
+    template <typename T> struct abs_func : unary_function<T, T>
+    {
+        __device__ __forceinline__ T operator ()(typename TypeTraits<T>::ParameterType x) const
+        {
+            return abs(x);
+        }
+    };
+    template <> struct abs_func<unsigned char> : unary_function<unsigned char, unsigned char>
+    {
+        __device__ __forceinline__ unsigned char operator ()(unsigned char x) const
+        {
+            return x;
+        }
+    };
+    template <> struct abs_func<signed char> : unary_function<signed char, signed char>
+    {
+        __device__ __forceinline__ signed char operator ()(signed char x) const
+        {
+            return ::abs(x);
+        }
+    };
+    template <> struct abs_func<char> : unary_function<char, char>
+    {
+        __device__ __forceinline__ char operator ()(char x) const
+        {
+            return ::abs(x);
+        }
+    };
+    template <> struct abs_func<unsigned short> : unary_function<unsigned short, unsigned short>
+    {
+        __device__ __forceinline__ unsigned short operator ()(unsigned short x) const
+        {
+            return x;
+        }
+    };
+    template <> struct abs_func<short> : unary_function<short, short>
+    {
+        __device__ __forceinline__ short operator ()(short x) const
+        {
+            return ::abs(x);
+        }
+    };
+    template <> struct abs_func<unsigned int> : unary_function<unsigned int, unsigned int>
+    {
+        __device__ __forceinline__ unsigned int operator ()(unsigned int x) const
+        {
+            return x;
+        }
+    };
+    template <> struct abs_func<int> : unary_function<int, int>
+    {
+        __device__ __forceinline__ int operator ()(int x) const
+        {
+            return ::abs(x);
+        }
+    };
+    template <> struct abs_func<float> : unary_function<float, float>
+    {
+        __device__ __forceinline__ float operator ()(float x) const
+        {
+            return ::fabsf(x);
+        }
+    };
+    template <> struct abs_func<double> : unary_function<double, double>
+    {
+        __device__ __forceinline__ double operator ()(double x) const
+        {
+            return ::fabs(x);
+        }
+    };
+
 #define OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(name, func) \
     template <typename T> struct name ## _func : unary_function<T, float> \
     { \
@@ -382,7 +454,6 @@ namespace cv { namespace gpu { namespace device
         } \
     };
 
-    OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(fabs, ::fabs)
     OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(sqrt, ::sqrt)
     OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp, ::exp)
     OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(exp2, ::exp2)
diff --git a/modules/gpu/include/opencv2/gpu/device/vec_math.hpp b/modules/gpu/include/opencv2/gpu/device/vec_math.hpp
index 0ec790c0b..1c46dc0c3 100644
--- a/modules/gpu/include/opencv2/gpu/device/vec_math.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/vec_math.hpp
@@ -280,7 +280,7 @@ namespace cv { namespace gpu { namespace device
     OPENCV_GPU_IMPLEMENT_VEC_UNOP (type, operator ! , logical_not) \
     OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, max, maximum) \
     OPENCV_GPU_IMPLEMENT_VEC_BINOP(type, min, minimum) \
-    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, fabs, fabs_func) \
+    OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, abs, abs_func) \
     OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, sqrt, sqrt_func) \
     OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, exp, exp_func) \
     OPENCV_GPU_IMPLEMENT_VEC_UNOP(type, exp2, exp2_func) \
@@ -327,4 +327,4 @@ namespace cv { namespace gpu { namespace device
     #undef OPENCV_GPU_IMPLEMENT_VEC_INT_OP
 }}} // namespace cv { namespace gpu { namespace device
 
-#endif // __OPENCV_GPU_VECMATH_HPP__
\ No newline at end of file
+#endif // __OPENCV_GPU_VECMATH_HPP__
diff --git a/modules/gpu/src/cuda/pyrlk.cu b/modules/gpu/src/cuda/pyrlk.cu
index d1a65c210..811c3b90b 100644
--- a/modules/gpu/src/cuda/pyrlk.cu
+++ b/modules/gpu/src/cuda/pyrlk.cu
@@ -267,7 +267,7 @@ namespace cv { namespace gpu { namespace device
         }
         __device__ __forceinline__ float4 abs_(const float4& a)
         {
-            return fabs(a);
+            return abs(a);
         }
 
         template <int cn, int PATCH_X, int PATCH_Y, bool calcErr>
@@ -681,4 +681,4 @@ namespace cv { namespace gpu { namespace device
     }
 }}}
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index 8c80559c5..aebda0ea9 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -638,7 +638,7 @@ namespace cv { namespace gpu { namespace device
                 kp_dir *= 180.0f / CV_PI_F;
 
                 kp_dir = 360.0f - kp_dir;
-                if (abs(kp_dir - 360.f) < FLT_EPSILON)
+                if (::fabsf(kp_dir - 360.f) < FLT_EPSILON)
                     kp_dir = 0.f;
 
                 featureDir[blockIdx.x] = kp_dir;
@@ -1003,4 +1003,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 7a1874b2ccf9bafd12a343baa2f133194439f659 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 10:55:32 +0400
Subject: [PATCH 077/155] new reduce and reduceKeyVal implementation

---
 .../opencv2/gpu/device/detail/reduce.hpp      | 352 +++++++++++++
 .../gpu/device/detail/reduce_key_val.hpp      | 489 ++++++++++++++++++
 .../gpu/include/opencv2/gpu/device/reduce.hpp | 197 +++++++
 .../include/opencv2/gpu/device/utility.hpp    |   2 +-
 .../opencv2/gpu/device/vec_distance.hpp       |   8 +-
 .../opencv2/gpu/device/warp_shuffle.hpp       |  97 ++++
 modules/gpu/src/cuda/orb.cu                   |  14 +-
 modules/gpu/src/cuda/surf.cu                  |   4 +-
 8 files changed, 1149 insertions(+), 14 deletions(-)
 create mode 100644 modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
 create mode 100644 modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
 create mode 100644 modules/gpu/include/opencv2/gpu/device/reduce.hpp
 create mode 100644 modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
new file mode 100644
index 000000000..628129ea3
--- /dev/null
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
@@ -0,0 +1,352 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_GPU_REDUCE_DETAIL_HPP__
+#define __OPENCV_GPU_REDUCE_DETAIL_HPP__
+
+#include <thrust/tuple.h>
+#include "../warp.hpp"
+#include "../warp_shuffle.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    namespace reduce_detail
+    {
+        template <typename T> struct GetType;
+        template <typename T> struct GetType<T*>
+        {
+            typedef T type;
+        };
+        template <typename T> struct GetType<volatile T*>
+        {
+            typedef T type;
+        };
+        template <typename T> struct GetType<T&>
+        {
+            typedef T type;
+        };
+
+        template <unsigned int I, unsigned int N>
+        struct For
+        {
+            template <class PointerTuple, class ValTuple>
+            static __device__ void loadToSmem(const PointerTuple& smem, const ValTuple& val, unsigned int tid)
+            {
+                thrust::get<I>(smem)[tid] = thrust::get<I>(val);
+
+                For<I + 1, N>::loadToSmem(smem, val, tid);
+            }
+            template <class PointerTuple, class ValTuple>
+            static __device__ void loadFromSmem(const PointerTuple& smem, const ValTuple& val, unsigned int tid)
+            {
+                thrust::get<I>(val) = thrust::get<I>(smem)[tid];
+
+                For<I + 1, N>::loadFromSmem(smem, val, tid);
+            }
+
+            template <class PointerTuple, class ValTuple, class OpTuple>
+            static __device__ void merge(const PointerTuple& smem, const ValTuple& val, unsigned int tid, unsigned int delta, const OpTuple& op)
+            {
+                typename GetType<typename thrust::tuple_element<I, PointerTuple>::type>::type reg = thrust::get<I>(smem)[tid + delta];
+                thrust::get<I>(smem)[tid] = thrust::get<I>(val) = thrust::get<I>(op)(thrust::get<I>(val), reg);
+
+                For<I + 1, N>::merge(smem, val, tid, delta, op);
+            }
+            template <class ValTuple, class OpTuple>
+            static __device__ void mergeShfl(const ValTuple& val, unsigned int delta, unsigned int width, const OpTuple& op)
+            {
+                typename GetType<typename thrust::tuple_element<I, ValTuple>::type>::type reg = shfl_down(thrust::get<I>(val), delta, width);
+                thrust::get<I>(val) = thrust::get<I>(op)(thrust::get<I>(val), reg);
+
+                For<I + 1, N>::mergeShfl(val, delta, width, op);
+            }
+        };
+        template <unsigned int N>
+        struct For<N, N>
+        {
+            template <class PointerTuple, class ValTuple>
+            static __device__ void loadToSmem(const PointerTuple&, const ValTuple&, unsigned int)
+            {
+            }
+            template <class PointerTuple, class ValTuple>
+            static __device__ void loadFromSmem(const PointerTuple&, const ValTuple&, unsigned int)
+            {
+            }
+
+            template <class PointerTuple, class ValTuple, class OpTuple>
+            static __device__ void merge(const PointerTuple&, const ValTuple&, unsigned int, unsigned int, const OpTuple&)
+            {
+            }
+            template <class ValTuple, class OpTuple>
+            static __device__ void mergeShfl(const ValTuple&, unsigned int, unsigned int, const OpTuple&)
+            {
+            }
+        };
+
+        template <typename T>
+        __device__ __forceinline__ void loadToSmem(volatile T* smem, T& val, unsigned int tid)
+        {
+            smem[tid] = val;
+        }
+        template <typename T>
+        __device__ __forceinline__ void loadFromSmem(volatile T* smem, T& val, unsigned int tid)
+        {
+            val = smem[tid];
+        }
+        template <typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9,
+                  typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, typename R6, typename R7, typename R8, typename R9>
+        __device__ __forceinline__ void loadToSmem(const thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>& smem,
+                                                       const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
+                                                       unsigned int tid)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> >::value>::loadToSmem(smem, val, tid);
+        }
+        template <typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9,
+                  typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, typename R6, typename R7, typename R8, typename R9>
+        __device__ __forceinline__ void loadFromSmem(const thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>& smem,
+                                                         const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
+                                                         unsigned int tid)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> >::value>::loadFromSmem(smem, val, tid);
+        }
+
+        template <typename T, class Op>
+        __device__ __forceinline__ void merge(volatile T* smem, T& val, unsigned int tid, unsigned int delta, const Op& op)
+        {
+            T reg = smem[tid + delta];
+            smem[tid] = val = op(val, reg);
+        }
+        template <typename T, class Op>
+        __device__ __forceinline__ void mergeShfl(T& val, unsigned int delta, unsigned int width, const Op& op)
+        {
+            T reg = shfl_down(val, delta, width);
+            val = op(val, reg);
+        }
+        template <typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9,
+                  typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, typename R6, typename R7, typename R8, typename R9,
+                  class Op0, class Op1, class Op2, class Op3, class Op4, class Op5, class Op6, class Op7, class Op8, class Op9>
+        __device__ __forceinline__ void merge(const thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>& smem,
+                                              const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
+                                              unsigned int tid,
+                                              unsigned int delta,
+                                              const thrust::tuple<Op0, Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, Op9>& op)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9> >::value>::merge(smem, val, tid, delta, op);
+        }
+        template <typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, typename R6, typename R7, typename R8, typename R9,
+                  class Op0, class Op1, class Op2, class Op3, class Op4, class Op5, class Op6, class Op7, class Op8, class Op9>
+        __device__ __forceinline__ void mergeShfl(const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
+                                                  unsigned int delta,
+                                                  unsigned int width,
+                                                  const thrust::tuple<Op0, Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, Op9>& op)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9> >::value>::mergeShfl(val, delta, width, op);
+        }
+
+        template <unsigned int N> struct Generic
+        {
+            template <typename Pointer, typename Reference, class Op>
+            static __device__ void reduce(Pointer smem, Reference val, unsigned int tid, Op op)
+            {
+                loadToSmem(smem, val, tid);
+                if (N >= 32)
+                    __syncthreads();
+
+                if (N >= 2048)
+                {
+                    if (tid < 1024)
+                        merge(smem, val, tid, 1024, op);
+
+                    __syncthreads();
+                }
+                if (N >= 1024)
+                {
+                    if (tid < 512)
+                        merge(smem, val, tid, 512, op);
+
+                    __syncthreads();
+                }
+                if (N >= 512)
+                {
+                    if (tid < 256)
+                        merge(smem, val, tid, 256, op);
+
+                    __syncthreads();
+                }
+                if (N >= 256)
+                {
+                    if (tid < 128)
+                        merge(smem, val, tid, 128, op);
+
+                    __syncthreads();
+                }
+                if (N >= 128)
+                {
+                    if (tid < 64)
+                        merge(smem, val, tid, 64, op);
+
+                    __syncthreads();
+                }
+                if (N >= 64)
+                {
+                    if (tid < 32)
+                        merge(smem, val, tid, 32, op);
+                }
+
+                if (tid < 16)
+                {
+                    merge(smem, val, tid, 16, op);
+                    merge(smem, val, tid, 8, op);
+                    merge(smem, val, tid, 4, op);
+                    merge(smem, val, tid, 2, op);
+                    merge(smem, val, tid, 1, op);
+                }
+            }
+        };
+
+        template <unsigned int N> struct WarpOptimized
+        {
+            template <typename Pointer, typename Reference, class Op>
+            static __device__ void reduce(Pointer smem, Reference val, unsigned int tid, Op op)
+            {
+            #if __CUDA_ARCH >= 300
+                (void) smem;
+                (void) tid;
+
+                #pragma unroll
+                for (unsigned int i = N / 2; i >= 1; i /= 2)
+                    mergeShfl(val, i, N, op);
+            #else
+                loadToSmem(smem, val, tid);
+
+                if (tid < N / 2)
+                {
+                    #pragma unroll
+                    for (unsigned int i = N / 2; i >= 1; i /= 2)
+                        merge(smem, val, tid, i, op);
+                }
+            #endif
+            }
+        };
+
+        template <unsigned int N> struct GenericOptimized32
+        {
+            enum { M = N / 32 };
+
+            template <typename Pointer, typename Reference, class Op>
+            static __device__ void reduce(Pointer smem, Reference val, unsigned int tid, Op op)
+            {
+                const unsigned int laneId = Warp::laneId();
+
+            #if __CUDA_ARCH >= 300
+                #pragma unroll
+                for (int i = 16; i >= 1; i /= 2)
+                    mergeShfl(val, i, warpSize, op);
+
+                if (laneId == 0)
+                    loadToSmem(smem, val, tid / 32);
+            #else
+                loadToSmem(smem, val, tid);
+
+                if (laneId < 16)
+                {
+                    #pragma unroll
+                    for (int i = 16; i >= 1; i /= 2)
+                        merge(smem, val, tid, i, op);
+                }
+
+                __syncthreads();
+
+                if (laneId == 0)
+                    loadToSmem(smem, val, tid / 32);
+            #endif
+
+                __syncthreads();
+
+                loadFromSmem(smem, val, tid);
+
+                if (tid < 32)
+                {
+                #if __CUDA_ARCH >= 300
+                    #pragma unroll
+                    for (int i = M / 2; i >= 1; i /= 2)
+                        mergeShfl(val, i, M, op);
+                #else
+                    #pragma unroll
+                    for (int i = M / 2; i >= 1; i /= 2)
+                        merge(smem, val, tid, i, op);
+                #endif
+                }
+            }
+        };
+
+        template <bool val, class T1, class T2> struct StaticIf;
+        template <class T1, class T2> struct StaticIf<true, T1, T2>
+        {
+            typedef T1 type;
+        };
+        template <class T1, class T2> struct StaticIf<false, T1, T2>
+        {
+            typedef T2 type;
+        };
+
+        template <unsigned int N> struct IsPowerOf2
+        {
+            enum { value = ((N != 0) && !(N & (N - 1))) };
+        };
+
+        template <unsigned int N> struct Dispatcher
+        {
+            typedef typename StaticIf<
+                (N <= 32) && IsPowerOf2<N>::value,
+                WarpOptimized<N>,
+                typename StaticIf<
+                    (N <= 1024) && IsPowerOf2<N>::value,
+                    GenericOptimized32<N>,
+                    Generic<N>
+                >::type
+            >::type reductor;
+        };
+    }
+}}}
+
+#endif // __OPENCV_GPU_REDUCE_DETAIL_HPP__
diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
new file mode 100644
index 000000000..f7531da24
--- /dev/null
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
@@ -0,0 +1,489 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
+#define __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
+
+#include <thrust/tuple.h>
+#include "../warp.hpp"
+#include "../warp_shuffle.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    namespace reduce_key_val_detail
+    {
+        template <typename T> struct GetType;
+        template <typename T> struct GetType<T*>
+        {
+            typedef T type;
+        };
+        template <typename T> struct GetType<volatile T*>
+        {
+            typedef T type;
+        };
+        template <typename T> struct GetType<T&>
+        {
+            typedef T type;
+        };
+
+        template <unsigned int I, unsigned int N>
+        struct For
+        {
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void loadToSmem(const PointerTuple& smem, const ReferenceTuple& data, unsigned int tid)
+            {
+                thrust::get<I>(smem)[tid] = thrust::get<I>(data);
+
+                For<I + 1, N>::loadToSmem(smem, data, tid);
+            }
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void loadFromSmem(const PointerTuple& smem, const ReferenceTuple& data, unsigned int tid)
+            {
+                thrust::get<I>(data) = thrust::get<I>(smem)[tid];
+
+                For<I + 1, N>::loadFromSmem(smem, data, tid);
+            }
+
+            template <class ReferenceTuple>
+            static __device__ void copyShfl(const ReferenceTuple& val, unsigned int delta, int width)
+            {
+                thrust::get<I>(val) = shfl_down(thrust::get<I>(val), delta, width);
+
+                For<I + 1, N>::copyShfl(val, delta, width);
+            }
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void copy(const PointerTuple& svals, const ReferenceTuple& val, unsigned int tid, unsigned int delta)
+            {
+                thrust::get<I>(svals)[tid] = thrust::get<I>(val) = thrust::get<I>(svals)[tid + delta];
+
+                For<I + 1, N>::copy(svals, val, tid, delta);
+            }
+
+            template <class KeyReferenceTuple, class ValReferenceTuple, class CmpTuple>
+            static __device__ void mergeShfl(const KeyReferenceTuple& key, const ValReferenceTuple& val, const CmpTuple& cmp, unsigned int delta, int width)
+            {
+                typename GetType<typename thrust::tuple_element<I, KeyReferenceTuple>::type>::type reg = shfl_down(thrust::get<I>(key), delta, width);
+
+                if (thrust::get<I>(cmp)(reg, thrust::get<I>(key)))
+                {
+                    thrust::get<I>(key) = reg;
+                    thrust::get<I>(val) = shfl_down(thrust::get<I>(val), delta, width);
+                }
+
+                For<I + 1, N>::mergeShfl(key, val, cmp, delta, width);
+            }
+            template <class KeyPointerTuple, class KeyReferenceTuple, class ValPointerTuple, class ValReferenceTuple, class CmpTuple>
+            static __device__ void merge(const KeyPointerTuple& skeys, const KeyReferenceTuple& key,
+                                         const ValPointerTuple& svals, const ValReferenceTuple& val,
+                                         const CmpTuple& cmp,
+                                         unsigned int tid, unsigned int delta)
+            {
+                typename GetType<typename thrust::tuple_element<I, KeyPointerTuple>::type>::type reg = thrust::get<I>(skeys)[tid + delta];
+
+                if (thrust::get<I>(cmp)(reg, thrust::get<I>(key)))
+                {
+                    thrust::get<I>(skeys)[tid] = thrust::get<I>(key) = reg;
+                    thrust::get<I>(svals)[tid] = thrust::get<I>(val) = thrust::get<I>(svals)[tid + delta];
+                }
+
+                For<I + 1, N>::merge(skeys, key, svals, val, cmp, tid, delta);
+            }
+        };
+        template <unsigned int N>
+        struct For<N, N>
+        {
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void loadToSmem(const PointerTuple&, const ReferenceTuple&, unsigned int)
+            {
+            }
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void loadFromSmem(const PointerTuple&, const ReferenceTuple&, unsigned int)
+            {
+            }
+
+            template <class ReferenceTuple>
+            static __device__ void copyShfl(const ReferenceTuple&, unsigned int, int)
+            {
+            }
+            template <class PointerTuple, class ReferenceTuple>
+            static __device__ void copy(const PointerTuple&, const ReferenceTuple&, unsigned int, unsigned int)
+            {
+            }
+
+            template <class KeyReferenceTuple, class ValReferenceTuple, class CmpTuple>
+            static __device__ void mergeShfl(const KeyReferenceTuple&, const ValReferenceTuple&, const CmpTuple&, unsigned int, int)
+            {
+            }
+            template <class KeyPointerTuple, class KeyReferenceTuple, class ValPointerTuple, class ValReferenceTuple, class CmpTuple>
+            static __device__ void merge(const KeyPointerTuple&, const KeyReferenceTuple&,
+                                         const ValPointerTuple&, const ValReferenceTuple&,
+                                         const CmpTuple&,
+                                         unsigned int, unsigned int)
+            {
+            }
+        };
+
+        //////////////////////////////////////////////////////
+        // loadToSmem
+
+        template <typename T>
+        __device__ __forceinline__ void loadToSmem(volatile T* smem, T& data, unsigned int tid)
+        {
+            smem[tid] = data;
+        }
+        template <typename T>
+        __device__ __forceinline__ void loadFromSmem(volatile T* smem, T& data, unsigned int tid)
+        {
+            data = smem[tid];
+        }
+        template <typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9>
+        __device__ __forceinline__ void loadToSmem(const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& smem,
+                                                   const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& data,
+                                                   unsigned int tid)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9> >::value>::loadToSmem(smem, data, tid);
+        }
+        template <typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9>
+        __device__ __forceinline__ void loadFromSmem(const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& smem,
+                                                     const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& data,
+                                                     unsigned int tid)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9> >::value>::loadFromSmem(smem, data, tid);
+        }
+
+        //////////////////////////////////////////////////////
+        // copyVals
+
+        template <typename V>
+        __device__ __forceinline__ void copyValsShfl(V& val, unsigned int delta, int width)
+        {
+            val = shfl_down(val, delta, width);
+        }
+        template <typename V>
+        __device__ __forceinline__ void copyVals(volatile V* svals, V& val, unsigned int tid, unsigned int delta)
+        {
+            svals[tid] = val = svals[tid + delta];
+        }
+        template <typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9>
+        __device__ __forceinline__ void copyValsShfl(const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                     unsigned int delta,
+                                                     int width)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9> >::value>::copyShfl(val, delta, width);
+        }
+        template <typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9>
+        __device__ __forceinline__ void copyVals(const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
+                                                 const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                 unsigned int tid, unsigned int delta)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9> >::value>::copy(svals, val, tid, delta);
+        }
+
+        //////////////////////////////////////////////////////
+        // merge
+
+        template <typename K, typename V, class Cmp>
+        __device__ __forceinline__ void mergeShfl(K& key, V& val, const Cmp& cmp, unsigned int delta, int width)
+        {
+            K reg = shfl_down(key, delta, width);
+
+            if (cmp(reg, key))
+            {
+                key = reg;
+                copyValsShfl(val, delta, width);
+            }
+        }
+        template <typename K, typename V, class Cmp>
+        __device__ __forceinline__ void merge(volatile K* skeys, K& key, volatile V* svals, V& val, const Cmp& cmp, unsigned int tid, unsigned int delta)
+        {
+            K reg = skeys[tid + delta];
+
+            if (cmp(reg, key))
+            {
+                skeys[tid] = key = reg;
+                copyVals(svals, val, tid, delta);
+            }
+        }
+        template <typename K,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+                  class Cmp>
+        __device__ __forceinline__ void mergeShfl(K& key,
+                                                  const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                  const Cmp& cmp,
+                                                  unsigned int delta, int width)
+        {
+            K reg = shfl_down(key, delta, width);
+
+            if (cmp(reg, key))
+            {
+                key = reg;
+                copyValsShfl(val, delta, width);
+            }
+        }
+        template <typename K,
+                  typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+                  class Cmp>
+        __device__ __forceinline__ void merge(volatile K* skeys, K& key,
+                                              const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
+                                              const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                              const Cmp& cmp, unsigned int tid, unsigned int delta)
+        {
+            K reg = skeys[tid + delta];
+
+            if (cmp(reg, key))
+            {
+                skeys[tid] = key = reg;
+                copyVals(svals, val, tid, delta);
+            }
+        }
+        template <typename KR0, typename KR1, typename KR2, typename KR3, typename KR4, typename KR5, typename KR6, typename KR7, typename KR8, typename KR9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+                  class Cmp0, class Cmp1, class Cmp2, class Cmp3, class Cmp4, class Cmp5, class Cmp6, class Cmp7, class Cmp8, class Cmp9>
+        __device__ __forceinline__ void mergeShfl(const thrust::tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9>& key,
+                                                  const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                  const thrust::tuple<Cmp0, Cmp1, Cmp2, Cmp3, Cmp4, Cmp5, Cmp6, Cmp7, Cmp8, Cmp9>& cmp,
+                                                  unsigned int delta, int width)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9> >::value>::mergeShfl(key, val, cmp, delta, width);
+        }
+        template <typename KP0, typename KP1, typename KP2, typename KP3, typename KP4, typename KP5, typename KP6, typename KP7, typename KP8, typename KP9,
+                  typename KR0, typename KR1, typename KR2, typename KR3, typename KR4, typename KR5, typename KR6, typename KR7, typename KR8, typename KR9,
+                  typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+                  typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+                  class Cmp0, class Cmp1, class Cmp2, class Cmp3, class Cmp4, class Cmp5, class Cmp6, class Cmp7, class Cmp8, class Cmp9>
+        __device__ __forceinline__ void merge(const thrust::tuple<KP0, KP1, KP2, KP3, KP4, KP5, KP6, KP7, KP8, KP9>& skeys,
+                                              const thrust::tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9>& key,
+                                              const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
+                                              const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                              const thrust::tuple<Cmp0, Cmp1, Cmp2, Cmp3, Cmp4, Cmp5, Cmp6, Cmp7, Cmp8, Cmp9>& cmp,
+                                              unsigned int tid, unsigned int delta)
+        {
+            For<0, thrust::tuple_size<thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9> >::value>::merge(skeys, key, svals, val, cmp, tid, delta);
+        }
+
+        //////////////////////////////////////////////////////
+        // Generic
+
+        template <unsigned int N> struct Generic
+        {
+            template <class KP, class KR, class VP, class VR, class Cmp>
+            static __device__ void reduce(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
+            {
+                loadToSmem(skeys, key, tid);
+                loadValsToSmem(svals, val, tid);
+                if (N >= 32)
+                    __syncthreads();
+
+                if (N >= 2048)
+                {
+                    if (tid < 1024)
+                        merge(skeys, key, svals, val, cmp, tid, 1024);
+
+                    __syncthreads();
+                }
+                if (N >= 1024)
+                {
+                    if (tid < 512)
+                        merge(skeys, key, svals, val, cmp, tid, 512);
+
+                    __syncthreads();
+                }
+                if (N >= 512)
+                {
+                    if (tid < 256)
+                        merge(skeys, key, svals, val, cmp, tid, 256);
+
+                    __syncthreads();
+                }
+                if (N >= 256)
+                {
+                    if (tid < 128)
+                        merge(skeys, key, svals, val, cmp, tid, 128);
+
+                    __syncthreads();
+                }
+                if (N >= 128)
+                {
+                    if (tid < 64)
+                        merge(skeys, key, svals, val, cmp, tid, 64);
+
+                    __syncthreads();
+                }
+                if (N >= 64)
+                {
+                    if (tid < 32)
+                        merge(skeys, key, svals, val, cmp, tid, 32);
+                }
+
+                if (tid < 16)
+                {
+                    merge(skeys, key, svals, val, cmp, tid, 16);
+                    merge(skeys, key, svals, val, cmp, tid, 8);
+                    merge(skeys, key, svals, val, cmp, tid, 4);
+                    merge(skeys, key, svals, val, cmp, tid, 2);
+                    merge(skeys, key, svals, val, cmp, tid, 1);
+                }
+            }
+        };
+
+        template <unsigned int N> struct WarpOptimized
+        {
+            template <class KP, class KR, class VP, class VR, class Cmp>
+            static __device__ void reduce(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
+            {
+            #if __CUDA_ARCH >= 300
+                (void) skeys;
+                (void) svals;
+                (void) tid;
+
+                #pragma unroll
+                for (unsigned int i = N / 2; i >= 1; i /= 2)
+                    mergeShfl(key, val, cml, i, N);
+            #else
+                loadToSmem(skeys, key, tid);
+                loadToSmem(svals, val, tid);
+
+                if (tid < N / 2)
+                {
+                    #pragma unroll
+                    for (unsigned int i = N / 2; i >= 1; i /= 2)
+                        merge(skeys, key, svals, val, cmp, tid, i);
+                }
+            #endif
+            }
+        };
+
+        template <unsigned int N> struct GenericOptimized32
+        {
+            enum { M = N / 32 };
+
+            template <class KP, class KR, class VP, class VR, class Cmp>
+            static __device__ void reduce(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
+            {
+                const unsigned int laneId = Warp::laneId();
+
+            #if __CUDA_ARCH >= 300
+                #pragma unroll
+                for (unsigned int i = 16; i >= 1; i /= 2)
+                    mergeShfl(key, val, cml, i, warpSize);
+
+                if (laneId == 0)
+                {
+                    loadToSmem(skeys, key, tid / 32);
+                    loadToSmem(svals, val, tid / 32);
+                }
+            #else
+                loadToSmem(skeys, key, tid);
+                loadToSmem(svals, val, tid);
+
+                if (laneId < 16)
+                {
+                    #pragma unroll
+                    for (int i = 16; i >= 1; i /= 2)
+                        merge(skeys, key, svals, val, cmp, tid, i);
+                }
+
+                __syncthreads();
+
+                if (laneId == 0)
+                {
+                    loadToSmem(skeys, key, tid / 32);
+                    loadToSmem(svals, val, tid / 32);
+                }
+            #endif
+
+                __syncthreads();
+
+                loadFromSmem(skeys, key, tid);
+
+                if (tid < 32)
+                {
+                #if __CUDA_ARCH >= 300
+                    loadFromSmem(svals, val, tid);
+
+                    #pragma unroll
+                    for (unsigned int i = M / 2; i >= 1; i /= 2)
+                        mergeShfl(key, val, cml, i, M);
+                #else
+                    #pragma unroll
+                    for (unsigned int i = M / 2; i >= 1; i /= 2)
+                        merge(skeys, key, svals, val, cmp, tid, i);
+                #endif
+                }
+            }
+        };
+
+        template <bool val, class T1, class T2> struct StaticIf;
+        template <class T1, class T2> struct StaticIf<true, T1, T2>
+        {
+            typedef T1 type;
+        };
+        template <class T1, class T2> struct StaticIf<false, T1, T2>
+        {
+            typedef T2 type;
+        };
+
+        template <unsigned int N> struct IsPowerOf2
+        {
+            enum { value = ((N != 0) && !(N & (N - 1))) };
+        };
+
+        template <unsigned int N> struct Dispatcher
+        {
+            typedef typename StaticIf<
+                (N <= 32) && IsPowerOf2<N>::value,
+                WarpOptimized<N>,
+                typename StaticIf<
+                    (N <= 1024) && IsPowerOf2<N>::value,
+                    GenericOptimized32<N>,
+                    Generic<N>
+                >::type
+            >::type reductor;
+        };
+    }
+}}}
+
+#endif // __OPENCV_GPU_PRED_VAL_REDUCE_DETAIL_HPP__
diff --git a/modules/gpu/include/opencv2/gpu/device/reduce.hpp b/modules/gpu/include/opencv2/gpu/device/reduce.hpp
new file mode 100644
index 000000000..2161b0649
--- /dev/null
+++ b/modules/gpu/include/opencv2/gpu/device/reduce.hpp
@@ -0,0 +1,197 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_GPU_REDUCE_HPP__
+#define __OPENCV_GPU_REDUCE_HPP__
+
+#include <thrust/tuple.h>
+#include "detail/reduce.hpp"
+#include "detail/reduce_key_val.hpp"
+
+namespace cv { namespace gpu { namespace device
+{
+    template <int N, typename T, class Op>
+    __device__ __forceinline__ void reduce(volatile T* smem, T& val, unsigned int tid, const Op& op)
+    {
+        reduce_detail::Dispatcher<N>::reductor::template reduce<volatile T*, T&, const Op&>(smem, val, tid, op);
+    }
+    template <int N,
+              typename P0, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9,
+              typename R0, typename R1, typename R2, typename R3, typename R4, typename R5, typename R6, typename R7, typename R8, typename R9,
+              class Op0, class Op1, class Op2, class Op3, class Op4, class Op5, class Op6, class Op7, class Op8, class Op9>
+    __device__ __forceinline__ void reduce(const thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>& smem,
+                                           const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>& val,
+                                           unsigned int tid,
+                                           const thrust::tuple<Op0, Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, Op9>& op)
+    {
+        reduce_detail::Dispatcher<N>::reductor::template reduce<
+                const thrust::tuple<P0, P1, P2, P3, P4, P5, P6, P7, P8, P9>&,
+                const thrust::tuple<R0, R1, R2, R3, R4, R5, R6, R7, R8, R9>&,
+                const thrust::tuple<Op0, Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8, Op9>&>(smem, val, tid, op);
+    }
+
+    template <unsigned int N, typename K, typename V, class Cmp>
+    __device__ __forceinline__ void reduceKeyVal(volatile K* skeys, K& key, volatile V* svals, V& val, unsigned int tid, const Cmp& cmp)
+    {
+        reduce_key_val_detail::Dispatcher<N>::reductor::template reduce<volatile K*, K&, volatile V*, V&, const Cmp&>(skeys, key, svals, val, tid, cmp);
+    }
+    template <unsigned int N,
+              typename K,
+              typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+              typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+              class Cmp>
+    __device__ __forceinline__ void reduceKeyVal(volatile K* skeys, K& key,
+                                                 const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
+                                                 const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                 unsigned int tid, const Cmp& cmp)
+    {
+        reduce_key_val_detail::Dispatcher<N>::reductor::template reduce<volatile K*, K&,
+                const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>&,
+                const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>&,
+                const Cmp&>(skeys, key, svals, val, tid, cmp);
+    }
+    template <unsigned int N,
+              typename KP0, typename KP1, typename KP2, typename KP3, typename KP4, typename KP5, typename KP6, typename KP7, typename KP8, typename KP9,
+              typename KR0, typename KR1, typename KR2, typename KR3, typename KR4, typename KR5, typename KR6, typename KR7, typename KR8, typename KR9,
+              typename VP0, typename VP1, typename VP2, typename VP3, typename VP4, typename VP5, typename VP6, typename VP7, typename VP8, typename VP9,
+              typename VR0, typename VR1, typename VR2, typename VR3, typename VR4, typename VR5, typename VR6, typename VR7, typename VR8, typename VR9,
+              class Cmp0, class Cmp1, class Cmp2, class Cmp3, class Cmp4, class Cmp5, class Cmp6, class Cmp7, class Cmp8, class Cmp9>
+    __device__ __forceinline__ void reduceKeyVal(const thrust::tuple<KP0, KP1, KP2, KP3, KP4, KP5, KP6, KP7, KP8, KP9>& skeys,
+                                                 const thrust::tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9>& key,
+                                                 const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>& svals,
+                                                 const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>& val,
+                                                 unsigned int tid,
+                                                 const thrust::tuple<Cmp0, Cmp1, Cmp2, Cmp3, Cmp4, Cmp5, Cmp6, Cmp7, Cmp8, Cmp9>& cmp)
+    {
+        reduce_key_val_detail::Dispatcher<N>::reductor::template reduce<
+                const thrust::tuple<KP0, KP1, KP2, KP3, KP4, KP5, KP6, KP7, KP8, KP9>&,
+                const thrust::tuple<KR0, KR1, KR2, KR3, KR4, KR5, KR6, KR7, KR8, KR9>&,
+                const thrust::tuple<VP0, VP1, VP2, VP3, VP4, VP5, VP6, VP7, VP8, VP9>&,
+                const thrust::tuple<VR0, VR1, VR2, VR3, VR4, VR5, VR6, VR7, VR8, VR9>&,
+                const thrust::tuple<Cmp0, Cmp1, Cmp2, Cmp3, Cmp4, Cmp5, Cmp6, Cmp7, Cmp8, Cmp9>&
+                >(skeys, key, svals, val, tid, cmp);
+    }
+
+    // smem_tuple
+
+    template <typename T0>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*>
+    smem_tuple(T0* t0)
+    {
+        return thrust::make_tuple((volatile T0*) t0);
+    }
+
+    template <typename T0, typename T1>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*>
+    smem_tuple(T0* t0, T1* t1)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1);
+    }
+
+    template <typename T0, typename T1, typename T2>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*>
+    smem_tuple(T0* t0, T1* t1, T2* t2)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4, T5* t5)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4, T5* t5, T6* t6)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5, (volatile T6*) t6);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4, T5* t5, T6* t6, T7* t7)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5, (volatile T6*) t6, (volatile T7*) t7);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*, volatile T8*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4, T5* t5, T6* t6, T7* t7, T8* t8)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5, (volatile T6*) t6, (volatile T7*) t7, (volatile T8*) t8);
+    }
+
+    template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+    __device__ __forceinline__
+    thrust::tuple<volatile T0*, volatile T1*, volatile T2*, volatile T3*, volatile T4*, volatile T5*, volatile T6*, volatile T7*, volatile T8*, volatile T9*>
+    smem_tuple(T0* t0, T1* t1, T2* t2, T3* t3, T4* t4, T5* t5, T6* t6, T7* t7, T8* t8, T9* t9)
+    {
+        return thrust::make_tuple((volatile T0*) t0, (volatile T1*) t1, (volatile T2*) t2, (volatile T3*) t3, (volatile T4*) t4, (volatile T5*) t5, (volatile T6*) t6, (volatile T7*) t7, (volatile T8*) t8, (volatile T9*) t9);
+    }
+}}}
+
+#endif // __OPENCV_GPU_UTILITY_HPP__
diff --git a/modules/gpu/include/opencv2/gpu/device/utility.hpp b/modules/gpu/include/opencv2/gpu/device/utility.hpp
index 4489a20b1..e44d51a6a 100644
--- a/modules/gpu/include/opencv2/gpu/device/utility.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/utility.hpp
@@ -159,7 +159,7 @@ namespace cv { namespace gpu { namespace device
     ///////////////////////////////////////////////////////////////////////////////
     // Reduction
 
-    template <int n, typename T, typename Op> __device__ __forceinline__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
+    template <int n, typename T, typename Op> __device__ __forceinline__ void reduce_old(volatile T* data, T& partial_reduction, int tid, const Op& op)
     {
         StaticAssert<n >= 8 && n <= 512>::check();
         utility_detail::ReductionDispatcher<n <= 64>::reduce<n>(data, partial_reduction, tid, op);
diff --git a/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp b/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
index b7861bca7..f65af3aa5 100644
--- a/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
@@ -63,7 +63,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
         {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
         }
 
         __device__ __forceinline__ operator int() const
@@ -87,7 +87,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
         {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
         }
 
         __device__ __forceinline__ operator float() const
@@ -113,7 +113,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
         {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
         }
 
         __device__ __forceinline__ operator float() const
@@ -138,7 +138,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
         {
-            reduce<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
         }
 
         __device__ __forceinline__ operator int() const
diff --git a/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp b/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp
new file mode 100644
index 000000000..39b7e852a
--- /dev/null
+++ b/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp
@@ -0,0 +1,97 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#ifndef __OPENCV_GPU_WARP_SHUFFLE_HPP__
+#define __OPENCV_GPU_WARP_SHUFFLE_HPP__
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T>
+    __device__ __forceinline__ T shfl(T val, int srcLane, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return __shfl(val, srcLane, width);
+    #else
+        return T();
+    #endif
+    }
+    __device__ __forceinline__ double shfl(double val, int srcLane, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        int lo = __double2loint(val);
+        int hi = __double2hiint(val);
+
+        lo = __shfl(lo, srcLane, width);
+        hi = __shfl(hi, srcLane, width);
+
+        return __hiloint2double(hi, lo);
+    #else
+        return 0.0;
+    #endif
+    }
+
+    template <typename T>
+    __device__ __forceinline__ T shfl_down(T val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return __shfl_down(val, delta, width);
+    #else
+        return T();
+    #endif
+    }
+    __device__ __forceinline__ double shfl_down(double val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        int lo = __double2loint(val);
+        int hi = __double2hiint(val);
+
+        lo = __shfl_down(lo, delta, width);
+        hi = __shfl_down(hi, delta, width);
+
+        return __hiloint2double(hi, lo);
+    #else
+        return 0.0;
+    #endif
+    }
+}}}
+
+#endif // __OPENCV_GPU_WARP_SHUFFLE_HPP__
diff --git a/modules/gpu/src/cuda/orb.cu b/modules/gpu/src/cuda/orb.cu
index 2d441a472..91c570957 100644
--- a/modules/gpu/src/cuda/orb.cu
+++ b/modules/gpu/src/cuda/orb.cu
@@ -109,9 +109,9 @@ namespace cv { namespace gpu { namespace device
                     c += Ix * Iy;
                 }
 
-                reduce<32>(srow, a, threadIdx.x, plus<volatile int>());
-                reduce<32>(srow, b, threadIdx.x, plus<volatile int>());
-                reduce<32>(srow, c, threadIdx.x, plus<volatile int>());
+                reduce_old<32>(srow, a, threadIdx.x, plus<volatile int>());
+                reduce_old<32>(srow, b, threadIdx.x, plus<volatile int>());
+                reduce_old<32>(srow, c, threadIdx.x, plus<volatile int>());
 
                 if (threadIdx.x == 0)
                 {
@@ -167,7 +167,7 @@ namespace cv { namespace gpu { namespace device
                 for (int u = threadIdx.x - half_k; u <= half_k; u += blockDim.x)
                     m_10 += u * image(loc.y, loc.x + u);
 
-                reduce<32>(srow, m_10, threadIdx.x, plus<volatile int>());
+                reduce_old<32>(srow, m_10, threadIdx.x, plus<volatile int>());
 
                 for (int v = 1; v <= half_k; ++v)
                 {
@@ -185,8 +185,8 @@ namespace cv { namespace gpu { namespace device
                         m_sum += u * (val_plus + val_minus);
                     }
 
-                    reduce<32>(srow, v_sum, threadIdx.x, plus<volatile int>());
-                    reduce<32>(srow, m_sum, threadIdx.x, plus<volatile int>());
+                    reduce_old<32>(srow, v_sum, threadIdx.x, plus<volatile int>());
+                    reduce_old<32>(srow, m_sum, threadIdx.x, plus<volatile int>());
 
                     m_10 += m_sum;
                     m_01 += v * v_sum;
@@ -419,4 +419,4 @@ namespace cv { namespace gpu { namespace device
     }
 }}}
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index aebda0ea9..451fb425d 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -599,8 +599,8 @@ namespace cv { namespace gpu { namespace device
                     sumy += s_Y[threadIdx.x + 96];
                 }
 
-                device::reduce<32>(s_sumx + threadIdx.y * 32, sumx, threadIdx.x, plus<volatile float>());
-                device::reduce<32>(s_sumy + threadIdx.y * 32, sumy, threadIdx.x, plus<volatile float>());
+                device::reduce_old<32>(s_sumx + threadIdx.y * 32, sumx, threadIdx.x, plus<volatile float>());
+                device::reduce_old<32>(s_sumy + threadIdx.y * 32, sumy, threadIdx.x, plus<volatile float>());
 
                 const float temp_mod = sumx * sumx + sumy * sumy;
                 if (temp_mod > best_mod)

From 05db02fbc8af694c89c4740ecb067ce71eefd999 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 12:46:49 +0400
Subject: [PATCH 078/155] BruteForceMatcher

---
 .../opencv2/gpu/device/vec_distance.hpp       | 10 +-
 modules/gpu/src/cuda/bf_knnmatch.cu           | 97 ++++++++++++++++++-
 modules/gpu/src/cuda/bf_match.cu              | 21 ++--
 modules/gpu/src/cuda/bf_radius_match.cu       | 13 +--
 4 files changed, 108 insertions(+), 33 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp b/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
index f65af3aa5..d5b4bb202 100644
--- a/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/vec_distance.hpp
@@ -43,7 +43,7 @@
 #ifndef __OPENCV_GPU_VEC_DISTANCE_HPP__
 #define __OPENCV_GPU_VEC_DISTANCE_HPP__
 
-#include "utility.hpp"
+#include "reduce.hpp"
 #include "functional.hpp"
 #include "detail/vec_distance_detail.hpp"
 
@@ -63,7 +63,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
         {
-            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+            reduce<THREAD_DIM>(smem, mySum, tid, plus<int>());
         }
 
         __device__ __forceinline__ operator int() const
@@ -87,7 +87,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
         {
-            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+            reduce<THREAD_DIM>(smem, mySum, tid, plus<float>());
         }
 
         __device__ __forceinline__ operator float() const
@@ -113,7 +113,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(float* smem, int tid)
         {
-            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile float>());
+            reduce<THREAD_DIM>(smem, mySum, tid, plus<float>());
         }
 
         __device__ __forceinline__ operator float() const
@@ -138,7 +138,7 @@ namespace cv { namespace gpu { namespace device
 
         template <int THREAD_DIM> __device__ __forceinline__ void reduceAll(int* smem, int tid)
         {
-            reduce_old<THREAD_DIM>(smem, mySum, tid, plus<volatile int>());
+            reduce<THREAD_DIM>(smem, mySum, tid, plus<int>());
         }
 
         __device__ __forceinline__ operator int() const
diff --git a/modules/gpu/src/cuda/bf_knnmatch.cu b/modules/gpu/src/cuda/bf_knnmatch.cu
index 6a778735b..44e567b75 100644
--- a/modules/gpu/src/cuda/bf_knnmatch.cu
+++ b/modules/gpu/src/cuda/bf_knnmatch.cu
@@ -42,10 +42,13 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
+#include "opencv2/gpu/device/warp_shuffle.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -59,6 +62,45 @@ namespace cv { namespace gpu { namespace device
                                       int& bestTrainIdx1, int& bestTrainIdx2,
                                       float* s_distance, int* s_trainIdx)
         {
+        #if __CUDA_ARCH__ >= 300
+            (void) s_distance;
+            (void) s_trainIdx;
+
+            float d1, d2;
+            int i1, i2;
+
+            #pragma unroll
+            for (int i = BLOCK_SIZE / 2; i >= 1; i /= 2)
+            {
+                d1 = shfl_down(bestDistance1, i, BLOCK_SIZE);
+                d2 = shfl_down(bestDistance2, i, BLOCK_SIZE);
+                i1 = shfl_down(bestTrainIdx1, i, BLOCK_SIZE);
+                i2 = shfl_down(bestTrainIdx2, i, BLOCK_SIZE);
+
+                if (bestDistance1 < d1)
+                {
+                    if (d1 < bestDistance2)
+                    {
+                        bestDistance2 = d1;
+                        bestTrainIdx2 = i1;
+                    }
+                }
+                else
+                {
+                    bestDistance2 = bestDistance1;
+                    bestTrainIdx2 = bestTrainIdx1;
+
+                    bestDistance1 = d1;
+                    bestTrainIdx1 = i1;
+
+                    if (d2 < bestDistance2)
+                    {
+                        bestDistance2 = d2;
+                        bestTrainIdx2 = i2;
+                    }
+                }
+            }
+        #else
             float myBestDistance1 = numeric_limits<float>::max();
             float myBestDistance2 = numeric_limits<float>::max();
             int myBestTrainIdx1 = -1;
@@ -122,6 +164,7 @@ namespace cv { namespace gpu { namespace device
 
             bestTrainIdx1 = myBestTrainIdx1;
             bestTrainIdx2 = myBestTrainIdx2;
+        #endif
         }
 
         template <int BLOCK_SIZE>
@@ -130,6 +173,53 @@ namespace cv { namespace gpu { namespace device
                                        int& bestImgIdx1, int& bestImgIdx2,
                                        float* s_distance, int* s_trainIdx, int* s_imgIdx)
         {
+        #if __CUDA_ARCH__ >= 300
+            (void) s_distance;
+            (void) s_trainIdx;
+            (void) s_imgIdx;
+
+            float d1, d2;
+            int i1, i2;
+            int j1, j2;
+
+            #pragma unroll
+            for (int i = BLOCK_SIZE / 2; i >= 1; i /= 2)
+            {
+                d1 = shfl_down(bestDistance1, i, BLOCK_SIZE);
+                d2 = shfl_down(bestDistance2, i, BLOCK_SIZE);
+                i1 = shfl_down(bestTrainIdx1, i, BLOCK_SIZE);
+                i2 = shfl_down(bestTrainIdx2, i, BLOCK_SIZE);
+                j1 = shfl_down(bestImgIdx1, i, BLOCK_SIZE);
+                j2 = shfl_down(bestImgIdx2, i, BLOCK_SIZE);
+
+                if (bestDistance1 < d1)
+                {
+                    if (d1 < bestDistance2)
+                    {
+                        bestDistance2 = d1;
+                        bestTrainIdx2 = i1;
+                        bestImgIdx2 = j1;
+                    }
+                }
+                else
+                {
+                    bestDistance2 = bestDistance1;
+                    bestTrainIdx2 = bestTrainIdx1;
+                    bestImgIdx2 = bestImgIdx1;
+
+                    bestDistance1 = d1;
+                    bestTrainIdx1 = i1;
+                    bestImgIdx1 = j1;
+
+                    if (d2 < bestDistance2)
+                    {
+                        bestDistance2 = d2;
+                        bestTrainIdx2 = i2;
+                        bestImgIdx2 = j2;
+                    }
+                }
+            }
+        #else
             float myBestDistance1 = numeric_limits<float>::max();
             float myBestDistance2 = numeric_limits<float>::max();
             int myBestTrainIdx1 = -1;
@@ -205,6 +295,7 @@ namespace cv { namespace gpu { namespace device
 
             bestImgIdx1 = myBestImgIdx1;
             bestImgIdx2 = myBestImgIdx2;
+        #endif
         }
 
         ///////////////////////////////////////////////////////////////////////////////
@@ -1005,7 +1096,7 @@ namespace cv { namespace gpu { namespace device
             s_trainIdx[threadIdx.x] = bestIdx;
             __syncthreads();
 
-            reducePredVal<BLOCK_SIZE>(s_dist, dist, s_trainIdx, bestIdx, threadIdx.x, less<volatile float>());
+            reduceKeyVal<BLOCK_SIZE>(s_dist, dist, s_trainIdx, bestIdx, threadIdx.x, less<float>());
 
             if (threadIdx.x == 0)
             {
@@ -1164,4 +1255,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device {
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/bf_match.cu b/modules/gpu/src/cuda/bf_match.cu
index f50089ed9..9745dee82 100644
--- a/modules/gpu/src/cuda/bf_match.cu
+++ b/modules/gpu/src/cuda/bf_match.cu
@@ -42,7 +42,9 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
@@ -60,12 +62,7 @@ namespace cv { namespace gpu { namespace device
             s_distance += threadIdx.y * BLOCK_SIZE;
             s_trainIdx += threadIdx.y * BLOCK_SIZE;
 
-            s_distance[threadIdx.x] = bestDistance;
-            s_trainIdx[threadIdx.x] = bestTrainIdx;
-
-            __syncthreads();
-
-            reducePredVal<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, threadIdx.x, less<volatile float>());
+            reduceKeyVal<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, threadIdx.x, less<float>());
         }
 
         template <int BLOCK_SIZE>
@@ -75,13 +72,7 @@ namespace cv { namespace gpu { namespace device
             s_trainIdx += threadIdx.y * BLOCK_SIZE;
             s_imgIdx   += threadIdx.y * BLOCK_SIZE;
 
-            s_distance[threadIdx.x] = bestDistance;
-            s_trainIdx[threadIdx.x] = bestTrainIdx;
-            s_imgIdx  [threadIdx.x] = bestImgIdx;
-
-            __syncthreads();
-
-            reducePredVal2<BLOCK_SIZE>(s_distance, bestDistance, s_trainIdx, bestTrainIdx, s_imgIdx, bestImgIdx, threadIdx.x, less<volatile float>());
+            reduceKeyVal<BLOCK_SIZE>(s_distance, bestDistance, smem_tuple(s_trainIdx, s_imgIdx), thrust::tie(bestTrainIdx, bestImgIdx), threadIdx.x, less<float>());
         }
 
         ///////////////////////////////////////////////////////////////////////////////
@@ -782,4 +773,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device {
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/bf_radius_match.cu b/modules/gpu/src/cuda/bf_radius_match.cu
index 934b8fe84..bb828829f 100644
--- a/modules/gpu/src/cuda/bf_radius_match.cu
+++ b/modules/gpu/src/cuda/bf_radius_match.cu
@@ -42,7 +42,8 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/utility.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/vec_distance.hpp"
 #include "opencv2/gpu/device/datamov_utils.hpp"
@@ -58,8 +59,6 @@ namespace cv { namespace gpu { namespace device
         __global__ void matchUnrolled(const PtrStepSz<T> query, int imgIdx, const PtrStepSz<T> train, float maxDistance, const Mask mask,
             PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
         {
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-
             extern __shared__ int smem[];
 
             const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
@@ -110,8 +109,6 @@ namespace cv { namespace gpu { namespace device
                     bestDistance.ptr(queryIdx)[ind] = distVal;
                 }
             }
-
-            #endif
         }
 
         template <int BLOCK_SIZE, int MAX_DESC_LEN, typename Dist, typename T, typename Mask>
@@ -170,8 +167,6 @@ namespace cv { namespace gpu { namespace device
         __global__ void match(const PtrStepSz<T> query, int imgIdx, const PtrStepSz<T> train, float maxDistance, const Mask mask,
             PtrStepi bestTrainIdx, PtrStepi bestImgIdx, PtrStepf bestDistance, unsigned int* nMatches, int maxCount)
         {
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-
             extern __shared__ int smem[];
 
             const int queryIdx = blockIdx.y * BLOCK_SIZE + threadIdx.y;
@@ -221,8 +216,6 @@ namespace cv { namespace gpu { namespace device
                     bestDistance.ptr(queryIdx)[ind] = distVal;
                 }
             }
-
-            #endif
         }
 
         template <int BLOCK_SIZE, typename Dist, typename T, typename Mask>
@@ -469,4 +462,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From e2995956670488282b4743bc2841279f6481a2ee Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 12:50:00 +0400
Subject: [PATCH 079/155] computeHypothesisScoresKernel

---
 modules/gpu/src/cuda/calib3d.cu | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/modules/gpu/src/cuda/calib3d.cu b/modules/gpu/src/cuda/calib3d.cu
index 40c847547..0fd482c41 100644
--- a/modules/gpu/src/cuda/calib3d.cu
+++ b/modules/gpu/src/cuda/calib3d.cu
@@ -42,9 +42,10 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -66,6 +67,8 @@ namespace cv { namespace gpu { namespace device
                         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);
             }
+            __device__ __forceinline__ TransformOp() {}
+            __device__ __forceinline__ TransformOp(const TransformOp&) {}
         };
 
         void call(const PtrStepSz<float3> src, const float* rot,
@@ -103,6 +106,8 @@ namespace cv { namespace gpu { namespace device
                         (cproj0.x * t.x + cproj0.y * t.y) / t.z + cproj0.z,
                         (cproj1.x * t.x + cproj1.y * t.y) / t.z + cproj1.z);
             }
+            __device__ __forceinline__ ProjectOp() {}
+            __device__ __forceinline__ ProjectOp(const ProjectOp&) {}
         };
 
         void call(const PtrStepSz<float3> src, const float* rot,
@@ -134,6 +139,7 @@ namespace cv { namespace gpu { namespace device
             return x * x;
         }
 
+        template <int BLOCK_SIZE>
         __global__ void computeHypothesisScoresKernel(
                 const int num_points, const float3* object, const float2* image,
                 const float dist_threshold, int* g_num_inliers)
@@ -156,19 +162,11 @@ namespace cv { namespace gpu { namespace device
                     ++num_inliers;
             }
 
-            extern __shared__ float s_num_inliers[];
-            s_num_inliers[threadIdx.x] = num_inliers;
-            __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();
-            }
+            __shared__ int s_num_inliers[BLOCK_SIZE];
+            reduce<BLOCK_SIZE>(s_num_inliers, num_inliers, threadIdx.x, plus<int>());
 
             if (threadIdx.x == 0)
-                g_num_inliers[blockIdx.x] = s_num_inliers[0];
+                g_num_inliers[blockIdx.x] = num_inliers;
         }
 
         void computeHypothesisScores(
@@ -181,9 +179,8 @@ namespace cv { namespace gpu { namespace device
 
             dim3 threads(256);
             dim3 grid(num_hypotheses);
-            int smem_size = threads.x * sizeof(float);
 
-            computeHypothesisScoresKernel<<<grid, threads, smem_size>>>(
+            computeHypothesisScoresKernel<256><<<grid, threads>>>(
                     num_points, object, image, dist_threshold, hypothesis_scores);
             cudaSafeCall( cudaGetLastError() );
 
@@ -193,4 +190,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 28716d7f306cfc89d7e5507259e98a05bd9b7b8b Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 13:02:17 +0400
Subject: [PATCH 080/155] Canny

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  28 +-
 modules/gpu/src/cuda/canny.cu           | 790 ++++++++++++------------
 modules/gpu/src/imgproc.cpp             | 107 ++--
 modules/gpu/test/test_imgproc.cpp       |   2 +-
 4 files changed, 450 insertions(+), 477 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 2cbd45085..4396a0a10 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -792,31 +792,23 @@ private:
     GpuMat lab, l, ab;
 };
 
+struct CV_EXPORTS CannyBuf
+{
+    void create(const Size& image_size, int apperture_size = 3);
+    void release();
 
-struct CV_EXPORTS CannyBuf;
+    GpuMat dx, dy;
+    GpuMat mag;
+    GpuMat map;
+    GpuMat st1, st2;
+    Ptr<FilterEngine_GPU> filterDX, filterDY;
+};
 
 CV_EXPORTS void Canny(const GpuMat& image, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
 CV_EXPORTS void Canny(const GpuMat& image, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, int apperture_size = 3, bool L2gradient = false);
 CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
 CV_EXPORTS void Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& edges, double low_thresh, double high_thresh, bool L2gradient = false);
 
-struct CV_EXPORTS CannyBuf
-{
-    CannyBuf() {}
-    explicit CannyBuf(const Size& image_size, int apperture_size = 3) {create(image_size, apperture_size);}
-    CannyBuf(const GpuMat& dx_, const GpuMat& dy_);
-
-    void create(const Size& image_size, int apperture_size = 3);
-
-    void release();
-
-    GpuMat dx, dy;
-    GpuMat dx_buf, dy_buf;
-    GpuMat edgeBuf;
-    GpuMat trackBuf1, trackBuf2;
-    Ptr<FilterEngine_GPU> filterDX, filterDY;
-};
-
 class CV_EXPORTS ImagePyramid
 {
 public:
diff --git a/modules/gpu/src/cuda/canny.cu b/modules/gpu/src/cuda/canny.cu
index 3dc048678..b08a61c83 100644
--- a/modules/gpu/src/cuda/canny.cu
+++ b/modules/gpu/src/cuda/canny.cu
@@ -43,459 +43,463 @@
 #if !defined CUDA_DISABLER
 
 #include <utility>
-#include <algorithm>
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/emulation.hpp"
+#include "opencv2/gpu/device/transform.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
+{
+    struct L1 : binary_function<int, int, float>
+    {
+        __device__ __forceinline__ float operator ()(int x, int y) const
+        {
+            return ::abs(x) + ::abs(y);
+        }
+
+        __device__ __forceinline__ L1() {}
+        __device__ __forceinline__ L1(const L1&) {}
+    };
+    struct L2 : binary_function<int, int, float>
+    {
+        __device__ __forceinline__ float operator ()(int x, int y) const
+        {
+            return ::sqrtf(x * x + y * y);
+        }
+
+        __device__ __forceinline__ L2() {}
+        __device__ __forceinline__ L2(const L2&) {}
+    };
+}
 
 namespace cv { namespace gpu { namespace device
 {
-    namespace canny
+    template <> struct TransformFunctorTraits<L1> : DefaultTransformFunctorTraits<L1>
     {
-        __global__ void calcSobelRowPass(const PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits<L2> : DefaultTransformFunctorTraits<L2>
+    {
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace
+{
+    texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_src(false, cudaFilterModePoint, cudaAddressModeClamp);
+    struct SrcTex
+    {
+        const int xoff;
+        const int yoff;
+        __host__ SrcTex(int _xoff, int _yoff) : xoff(_xoff), yoff(_yoff) {}
+
+        __device__ __forceinline__ int operator ()(int y, int x) const
         {
-            __shared__ int smem[16][18];
+            return tex2D(tex_src, x + xoff, y + yoff);
+        }
+    };
 
-            const int j = blockIdx.x * blockDim.x + threadIdx.x;
-            const int i = blockIdx.y * blockDim.y + threadIdx.y;
+    template <class Norm> __global__
+    void calcMagnitude(const SrcTex src, PtrStepi dx, PtrStepi dy, PtrStepSzf mag, const Norm norm)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = 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][0] = src.ptr(i)[::max(j - 1, 0)];
-                    smem[threadIdx.y][17] = src.ptr(i)[::min(j + 16, cols - 1)];
-                }
-                __syncthreads();
+        if (y >= mag.rows || x >= mag.cols)
+            return;
 
-                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];
-                }
-            }
+        int dxVal = (src(y - 1, x + 1) + 2 * src(y, x + 1) + src(y + 1, x + 1)) - (src(y - 1, x - 1) + 2 * src(y, x - 1) + src(y + 1, x - 1));
+        int dyVal = (src(y + 1, x - 1) + 2 * src(y + 1, x) + src(y + 1, x + 1)) - (src(y - 1, x - 1) + 2 * src(y - 1, x) + src(y - 1, x + 1));
+
+        dx(y, x) = dxVal;
+        dy(y, x) = dyVal;
+
+        mag(y, x) = norm(dxVal, dyVal);
+    }
+}
+
+namespace canny
+{
+    void calcMagnitude(PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad)
+    {
+        const dim3 block(16, 16);
+        const dim3 grid(divUp(mag.cols, block.x), divUp(mag.rows, block.y));
+
+        bindTexture(&tex_src, srcWhole);
+        SrcTex src(xoff, yoff);
+
+        if (L2Grad)
+        {
+            L2 norm;
+            ::calcMagnitude<<<grid, block>>>(src, dx, dy, mag, norm);
+        }
+        else
+        {
+            L1 norm;
+            ::calcMagnitude<<<grid, block>>>(src, dx, dy, mag, norm);
         }
 
-        void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols)
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall(cudaThreadSynchronize());
+    }
+
+    void calcMagnitude(PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad)
+    {
+        if (L2Grad)
         {
-            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( cudaDeviceSynchronize() );
+            L2 norm;
+            transform(dx, dy, mag, norm, WithOutMask(), 0);
         }
-
-        struct L1
+        else
         {
-            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;
-
-            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);
-                }
-            }
+            L1 norm;
+            transform(dx, dy, mag, norm, WithOutMask(), 0);
         }
+    }
+}
 
-        void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+//////////////////////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_mag(false, cudaFilterModePoint, cudaAddressModeClamp);
+
+    __global__ void calcMap(const PtrStepSzi dx, const PtrStepi dy, PtrStepi map, const float low_thresh, const float high_thresh)
+    {
+        const int CANNY_SHIFT = 15;
+        const int TG22 = (int)(0.4142135623730950488016887242097*(1<<CANNY_SHIFT) + 0.5);
+
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (x >= dx.cols || y >= dx.rows)
+            return;
+
+        int dxVal = dx(y, x);
+        int dyVal = dy(y, x);
+
+        const int s = (dxVal ^ dyVal) < 0 ? -1 : 1;
+        const float m = tex2D(tex_mag, x, y);
+
+        dxVal = ::abs(dxVal);
+        dyVal = ::abs(dyVal);
+
+        // 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)
         {
-            dim3 block(16, 16, 1);
-            dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+            const int tg22x = dxVal * TG22;
+            const int tg67x = tg22x + ((dxVal + dxVal) << CANNY_SHIFT);
 
-            if (L2Grad)
-                calcMagnitude<L2><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
+            dyVal <<= CANNY_SHIFT;
+
+            if (dyVal < tg22x)
+            {
+                if (m > tex2D(tex_mag, x - 1, y) && m >= tex2D(tex_mag, x + 1, y))
+                    edge_type = 1 + (int)(m > high_thresh);
+            }
+            else if(dyVal > tg67x)
+            {
+                if (m > tex2D(tex_mag, x, y - 1) && m >= tex2D(tex_mag, x, y + 1))
+                    edge_type = 1 + (int)(m > high_thresh);
+            }
             else
-                calcMagnitude<L1><<<grid, block>>>(dx_buf, dy_buf, dx, dy, mag, rows, cols);
-
-            cudaSafeCall( cudaGetLastError() );
-
-            cudaSafeCall(cudaThreadSynchronize());
+            {
+                if (m > tex2D(tex_mag, x - s, y - 1) && m >= tex2D(tex_mag, x + s, y + 1))
+                    edge_type = 1 + (int)(m > high_thresh);
+            }
         }
 
-        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;
+        map(y, x) = edge_type;
+    }
+}
 
-            if (i < rows && j < cols)
-                mag.ptr(i + 1)[j + 1] = Norm::calc(dx.ptr(i)[j], dy.ptr(i)[j]);
+namespace canny
+{
+    void calcMap(PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, PtrStepSzi map, float low_thresh, float high_thresh)
+    {
+        const dim3 block(16, 16);
+        const dim3 grid(divUp(dx.cols, block.x), divUp(dx.rows, block.y));
+
+        bindTexture(&tex_mag, mag);
+
+        ::calcMap<<<grid, block>>>(dx, dy, map, low_thresh, high_thresh);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+    __device__ int counter = 0;
+
+    __global__ void edgesHysteresisLocal(PtrStepSzi map, ushort2* st)
+    {
+        __shared__ volatile int smem[18][18];
+
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        smem[threadIdx.y + 1][threadIdx.x + 1] = x < map.cols && y < map.rows ? map(y, x) : 0;
+        if (threadIdx.y == 0)
+            smem[0][threadIdx.x + 1] = y > 0 ? map(y - 1, x) : 0;
+        if (threadIdx.y == blockDim.y - 1)
+            smem[blockDim.y + 1][threadIdx.x + 1] = y + 1 < map.rows ? map(y + 1, x) : 0;
+        if (threadIdx.x == 0)
+            smem[threadIdx.y + 1][0] = x > 0 ? map(y, x - 1) : 0;
+        if (threadIdx.x == blockDim.x - 1)
+            smem[threadIdx.y + 1][blockDim.x + 1] = x + 1 < map.cols ? map(y, x + 1) : 0;
+        if (threadIdx.x == 0 && threadIdx.y == 0)
+            smem[0][0] = y > 0 && x > 0 ? map(y - 1, x - 1) : 0;
+        if (threadIdx.x == blockDim.x - 1 && threadIdx.y == 0)
+            smem[0][blockDim.x + 1] = y > 0 && x + 1 < map.cols ? map(y - 1, x + 1) : 0;
+        if (threadIdx.x == 0 && threadIdx.y == blockDim.y - 1)
+            smem[blockDim.y + 1][0] = y + 1 < map.rows && x > 0 ? map(y + 1, x - 1) : 0;
+        if (threadIdx.x == blockDim.x - 1 && threadIdx.y == blockDim.y - 1)
+            smem[blockDim.y + 1][blockDim.x + 1] = y + 1 < map.rows && x + 1 < map.cols ? map(y + 1, x + 1) : 0;
+
+        __syncthreads();
+
+        if (x >= map.cols || y >= map.rows)
+            return;
+
+        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;
         }
 
-        void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad)
+        const int e = smem[threadIdx.y + 1][threadIdx.x + 1];
+
+        map(y, x) = e;
+
+        n = 0;
+
+        if (e == 2)
         {
-            dim3 block(16, 16, 1);
-            dim3 grid(divUp(cols, block.x), divUp(rows, block.y), 1);
+            n += smem[threadIdx.y    ][threadIdx.x    ] == 1;
+            n += smem[threadIdx.y    ][threadIdx.x + 1] == 1;
+            n += smem[threadIdx.y    ][threadIdx.x + 2] == 1;
 
-            if (L2Grad)
-                calcMagnitude<L2><<<grid, block>>>(dx, dy, mag, rows, cols);
-            else
-                calcMagnitude<L1><<<grid, block>>>(dx, dy, mag, rows, cols);
+            n += smem[threadIdx.y + 1][threadIdx.x    ] == 1;
+            n += smem[threadIdx.y + 1][threadIdx.x + 2] == 1;
 
-            cudaSafeCall( cudaGetLastError() );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
+            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;
         }
 
-        //////////////////////////////////////////////////////////////////////////////////////////
-
-        #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)
+        if (n > 0)
         {
-            __shared__ float smem[18][18];
+            const int ind =  ::atomicAdd(&counter, 1);
+            st[ind] = make_ushort2(x, y);
+        }
+    }
+}
 
-            const int j = blockIdx.x * 16 + threadIdx.x;
-            const int i = blockIdx.y * 16 + threadIdx.y;
+namespace canny
+{
+    void edgesHysteresisLocal(PtrStepSzi map, ushort2* st1)
+    {
+        void* counter_ptr;
+        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, counter) );
 
-            const int tid = threadIdx.y * 16 + threadIdx.x;
-            const int lx = tid % 18;
-            const int ly = tid / 18;
+        cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(int)) );
 
-            if (ly < 14)
-                smem[ly][lx] = mag.ptr(blockIdx.y * 16 + ly)[blockIdx.x * 16 + lx];
+        const dim3 block(16, 16);
+        const dim3 grid(divUp(map.cols, block.x), divUp(map.rows, block.y));
 
-            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];
+        ::edgesHysteresisLocal<<<grid, block>>>(map, st1);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+    __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(PtrStepSzi map, ushort2* st1, ushort2* st2, const int count)
+    {
+        const int stack_size = 512;
+
+        __shared__ int s_counter;
+        __shared__ 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)
+            return;
+
+        ushort2 pos = st1[ind];
+
+        if (threadIdx.x < 8)
+        {
+            pos.x += c_dx[threadIdx.x];
+            pos.y += c_dy[threadIdx.x];
+
+            if (pos.x > 0 && pos.x <= map.cols && pos.y > 0 && pos.y <= map.rows && map(pos.y, pos.x) == 1)
+            {
+                map(pos.y, pos.x) = 2;
+
+                ind = Emulation::smem::atomicAdd(&s_counter, 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);
+
+            if (subTaskIdx < portion)
+                pos = s_st[s_counter - 1 - subTaskIdx];
 
             __syncthreads();
 
-            if (i < rows && j < cols)
-            {
-                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];
-
-                x = ::abs(x);
-                y = ::abs(y);
-
-                // 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)
-                {
-                    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);
-                    }
-                }
-
-                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);
-
-            calcMap<<<grid, block>>>(dx, dy, mag, map, rows, cols, low_thresh, high_thresh);
-            cudaSafeCall( cudaGetLastError() );
-
-            cudaSafeCall( cudaDeviceSynchronize() );
-        }
-
-        //////////////////////////////////////////////////////////////////////////////////////////
-
-        __device__ unsigned int counter = 0;
-
-        __global__ void edgesHysteresisLocal(PtrStepi map, ushort2* st, int rows, int cols)
-        {
-            #if defined (__CUDA_ARCH__) && (__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)
-            {
-                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)
-                {
-                    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 (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)
-        {
-            void* counter_ptr;
-            cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, counter) );
-
-            cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
-
-            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( cudaDeviceSynchronize() );
-        }
-
-        __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 defined (__CUDA_ARCH__) && __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;
+                s_counter -= portion;
+
             __syncthreads();
 
-            int ind = blockIdx.y * gridDim.x + blockIdx.x;
-
-            if (ind < count)
+            if (subTaskIdx < portion)
             {
-                ushort2 pos = st1[ind];
+                pos.x += c_dx[threadIdx.x & 7];
+                pos.y += c_dy[threadIdx.x & 7];
 
-                if (pos.x > 0 && pos.x <= cols && pos.y > 0 && pos.y <= rows)
+                if (pos.x > 0 && pos.x <= map.cols && pos.y > 0 && pos.y <= map.rows && map(pos.y, pos.x) == 1)
                 {
-                    if (threadIdx.x < 8)
-                    {
-                        pos.x += c_dx[threadIdx.x];
-                        pos.y += c_dy[threadIdx.x];
+                    map(pos.y, pos.x) = 2;
 
-                        if (map.ptr(pos.y)[pos.x] == 1)
-                        {
-                            map.ptr(pos.y)[pos.x] = 2;
+                    ind = Emulation::smem::atomicAdd(&s_counter, 1);
 
-                            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)
-                            {
-                                map.ptr(pos.y)[pos.x] = 2;
-
-                                ind = atomicInc(&s_counter, (unsigned int)(-1));
-
-                                s_st[ind] = pos;
-                            }
-                        }
-                        __syncthreads();
-                    }
-
-                    if (s_counter > 0)
-                    {
-                        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];
-                        }
-                    }
+                    s_st[ind] = pos;
                 }
             }
 
-            #endif
+            __syncthreads();
         }
 
-        void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols)
+        if (s_counter > 0)
         {
-            void* counter_ptr;
-            cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, counter) );
-
-            unsigned int count;
-            cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
-
-            while (count > 0)
+            if (threadIdx.x == 0)
             {
-                cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
-
-                dim3 block(128, 1, 1);
-                dim3 grid(std::min(count, 65535u), divUp(count, 65535), 1);
-                edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, rows, cols, count);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
-
-                std::swap(st1, st2);
+                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];
         }
+    }
+}
 
-        __global__ void getEdges(PtrStepi map, PtrStepb dst, int rows, int cols)
+namespace canny
+{
+    void edgesHysteresisGlobal(PtrStepSzi map, ushort2* st1, ushort2* st2)
+    {
+        void* counter_ptr;
+        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, ::counter) );
+
+        int count;
+        cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(int), cudaMemcpyDeviceToHost) );
+
+        while (count > 0)
         {
-            const int j = blockIdx.x * 16 + threadIdx.x;
-            const int i = blockIdx.y * 16 + threadIdx.y;
+            cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(int)) );
 
-            if (i < rows && j < cols)
-                dst.ptr(i)[j] = (uchar)(-(map.ptr(i + 1)[j + 1] >> 1));
-        }
+            const dim3 block(128);
+            const dim3 grid(::min(count, 65535u), divUp(count, 65535), 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);
+            ::edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, count);
             cudaSafeCall( cudaGetLastError() );
 
             cudaSafeCall( cudaDeviceSynchronize() );
+
+            cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(int), cudaMemcpyDeviceToHost) );
+
+            std::swap(st1, st2);
         }
-    } // namespace canny
-}}} // namespace cv { namespace gpu { namespace device
+    }
+}
 
+//////////////////////////////////////////////////////////////////////////////////////////
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+namespace
+{
+    struct GetEdges : unary_function<int, uchar>
+    {
+        __device__ __forceinline__ uchar operator ()(int e) const
+        {
+            return (uchar)(-(e >> 1));
+        }
+
+        __device__ __forceinline__ GetEdges() {}
+        __device__ __forceinline__ GetEdges(const GetEdges&) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits<GetEdges> : DefaultTransformFunctorTraits<GetEdges>
+    {
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace canny
+{
+    void getEdges(PtrStepSzi map, PtrStepSzb dst)
+    {
+        transform(map, dst, GetEdges(), WithOutMask(), 0);
+    }
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index 0bf9c81c2..b733faf5d 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -91,7 +91,6 @@ void cv::gpu::Canny(const GpuMat&, GpuMat&, double, double, int, bool) { throw_n
 void cv::gpu::Canny(const GpuMat&, CannyBuf&, GpuMat&, double, double, int, bool) { throw_nogpu(); }
 void cv::gpu::Canny(const GpuMat&, const GpuMat&, GpuMat&, double, double, bool) { throw_nogpu(); }
 void cv::gpu::Canny(const GpuMat&, const GpuMat&, CannyBuf&, GpuMat&, double, double, bool) { throw_nogpu(); }
-cv::gpu::CannyBuf::CannyBuf(const GpuMat&, const GpuMat&) { throw_nogpu(); }
 void cv::gpu::CannyBuf::create(const Size&, int) { throw_nogpu(); }
 void cv::gpu::CannyBuf::release() { throw_nogpu(); }
 
@@ -1466,92 +1465,76 @@ void cv::gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result,
 //////////////////////////////////////////////////////////////////////////////
 // Canny
 
-cv::gpu::CannyBuf::CannyBuf(const GpuMat& dx_, const GpuMat& dy_) : dx(dx_), dy(dy_)
-{
-    CV_Assert(dx_.type() == CV_32SC1 && dy_.type() == CV_32SC1 && dx_.size() == dy_.size());
-
-    create(dx_.size(), -1);
-}
-
 void cv::gpu::CannyBuf::create(const Size& image_size, int apperture_size)
 {
-    ensureSizeIsEnough(image_size, CV_32SC1, dx);
-    ensureSizeIsEnough(image_size, CV_32SC1, dy);
+    if (apperture_size > 0)
+    {
+        ensureSizeIsEnough(image_size, CV_32SC1, dx);
+        ensureSizeIsEnough(image_size, CV_32SC1, dy);
 
-    if (apperture_size == 3)
-    {
-        ensureSizeIsEnough(image_size, CV_32SC1, dx_buf);
-        ensureSizeIsEnough(image_size, CV_32SC1, dy_buf);
-    }
-    else if(apperture_size > 0)
-    {
-        if (!filterDX)
+        if (apperture_size != 3)
+        {
             filterDX = createDerivFilter_GPU(CV_8UC1, CV_32S, 1, 0, apperture_size, BORDER_REPLICATE);
-        if (!filterDY)
             filterDY = createDerivFilter_GPU(CV_8UC1, CV_32S, 0, 1, apperture_size, BORDER_REPLICATE);
+        }
     }
 
-    ensureSizeIsEnough(image_size.height + 2, image_size.width + 2, CV_32FC1, edgeBuf);
+    ensureSizeIsEnough(image_size, CV_32FC1, mag);
+    ensureSizeIsEnough(image_size, CV_32SC1, map);
 
-    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf1);
-    ensureSizeIsEnough(1, image_size.width * image_size.height, CV_16UC2, trackBuf2);
+    ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st1);
+    ensureSizeIsEnough(1, image_size.area(), CV_16UC2, st2);
 }
 
 void cv::gpu::CannyBuf::release()
 {
     dx.release();
     dy.release();
-    dx_buf.release();
-    dy_buf.release();
-    edgeBuf.release();
-    trackBuf1.release();
-    trackBuf2.release();
+    mag.release();
+    map.release();
+    st1.release();
+    st2.release();
 }
 
-namespace cv { namespace gpu { namespace device
+namespace canny
 {
-    namespace canny
-    {
-        void calcSobelRowPass_gpu(PtrStepb src, PtrStepi dx_buf, PtrStepi dy_buf, int rows, int cols);
+    void calcMagnitude(PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad);
+    void calcMagnitude(PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad);
 
-        void calcMagnitude_gpu(PtrStepi dx_buf, PtrStepi dy_buf, PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
-        void calcMagnitude_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, int rows, int cols, bool L2Grad);
+    void calcMap(PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, PtrStepSzi map, float low_thresh, float high_thresh);
 
-        void calcMap_gpu(PtrStepi dx, PtrStepi dy, PtrStepf mag, PtrStepi map, int rows, int cols, float low_thresh, float high_thresh);
+    void edgesHysteresisLocal(PtrStepSzi map, ushort2* st1);
 
-        void edgesHysteresisLocal_gpu(PtrStepi map, ushort2* st1, int rows, int cols);
+    void edgesHysteresisGlobal(PtrStepSzi map, ushort2* st1, ushort2* st2);
 
-        void edgesHysteresisGlobal_gpu(PtrStepi map, ushort2* st1, ushort2* st2, int rows, int cols);
-
-        void getEdges_gpu(PtrStepi map, PtrStepb dst, int rows, int cols);
-    }
-}}}
+    void getEdges(PtrStepSzi map, PtrStepSzb dst);
+}
 
 namespace
 {
-    void CannyCaller(CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh)
+    void CannyCaller(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& dst, float low_thresh, float high_thresh)
     {
-        using namespace ::cv::gpu::device::canny;
+        using namespace canny;
 
-        calcMap_gpu(buf.dx, buf.dy, buf.edgeBuf, buf.edgeBuf, dst.rows, dst.cols, low_thresh, high_thresh);
+        calcMap(dx, dy, buf.mag, buf.map, low_thresh, high_thresh);
 
-        edgesHysteresisLocal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), dst.rows, dst.cols);
+        edgesHysteresisLocal(buf.map, buf.st1.ptr<ushort2>());
 
-        edgesHysteresisGlobal_gpu(buf.edgeBuf, buf.trackBuf1.ptr<ushort2>(), buf.trackBuf2.ptr<ushort2>(), dst.rows, dst.cols);
+        edgesHysteresisGlobal(buf.map, buf.st1.ptr<ushort2>(), buf.st2.ptr<ushort2>());
 
-        getEdges_gpu(buf.edgeBuf, dst, dst.rows, dst.cols);
+        getEdges(buf.map, dst);
     }
 }
 
 void cv::gpu::Canny(const GpuMat& src, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient)
 {
-    CannyBuf buf(src.size(), apperture_size);
+    CannyBuf buf;
     Canny(src, buf, dst, low_thresh, high_thresh, apperture_size, L2gradient);
 }
 
 void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, int apperture_size, bool L2gradient)
 {
-    using namespace ::cv::gpu::device::canny;
+    using namespace canny;
 
     CV_Assert(src.type() == CV_8UC1);
 
@@ -1562,37 +1545,37 @@ void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_th
         std::swap( low_thresh, high_thresh);
 
     dst.create(src.size(), CV_8U);
-    dst.setTo(Scalar::all(0));
-
     buf.create(src.size(), apperture_size);
-    buf.edgeBuf.setTo(Scalar::all(0));
 
     if (apperture_size == 3)
     {
-        calcSobelRowPass_gpu(src, buf.dx_buf, buf.dy_buf, src.rows, src.cols);
+        Size wholeSize;
+        Point ofs;
+        src.locateROI(wholeSize, ofs);
+        GpuMat srcWhole(wholeSize, src.type(), src.datastart, src.step);
 
-        calcMagnitude_gpu(buf.dx_buf, buf.dy_buf, buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+        calcMagnitude(srcWhole, ofs.x, ofs.y, buf.dx, buf.dy, buf.mag, L2gradient);
     }
     else
     {
         buf.filterDX->apply(src, buf.dx, Rect(0, 0, src.cols, src.rows));
         buf.filterDY->apply(src, buf.dy, Rect(0, 0, src.cols, src.rows));
 
-        calcMagnitude_gpu(buf.dx, buf.dy, buf.edgeBuf, src.rows, src.cols, L2gradient);
+        calcMagnitude(buf.dx, buf.dy, buf.mag, L2gradient);
     }
 
-    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+    CannyCaller(buf.dx, buf.dy, buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
 }
 
 void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient)
 {
-    CannyBuf buf(dx, dy);
+    CannyBuf buf;
     Canny(dx, dy, buf, dst, low_thresh, high_thresh, L2gradient);
 }
 
 void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& dst, double low_thresh, double high_thresh, bool L2gradient)
 {
-    using namespace ::cv::gpu::device::canny;
+    using namespace canny;
 
     CV_Assert(TargetArchs::builtWith(SHARED_ATOMICS) && DeviceInfo().supports(SHARED_ATOMICS));
     CV_Assert(dx.type() == CV_32SC1 && dy.type() == CV_32SC1 && dx.size() == dy.size());
@@ -1601,17 +1584,11 @@ void cv::gpu::Canny(const GpuMat& dx, const GpuMat& dy, CannyBuf& buf, GpuMat& d
         std::swap( low_thresh, high_thresh);
 
     dst.create(dx.size(), CV_8U);
-    dst.setTo(Scalar::all(0));
-
-    buf.dx = dx; buf.dy = dy;
     buf.create(dx.size(), -1);
-    buf.edgeBuf.setTo(Scalar::all(0));
 
-    calcMagnitude_gpu(dx, dy, buf.edgeBuf, dx.rows, dx.cols, L2gradient);
+    calcMagnitude(dx, dy, buf.mag, L2gradient);
 
-    CannyCaller(buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
+    CannyCaller(dx, dy, buf, dst, static_cast<float>(low_thresh), static_cast<float>(high_thresh));
 }
 
 #endif /* !defined (HAVE_CUDA) */
-
-
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index e77cad69a..71d4a8e65 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -313,7 +313,7 @@ TEST_P(Canny, Accuracy)
         cv::Mat edges_gold;
         cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
 
-        EXPECT_MAT_SIMILAR(edges_gold, edges, 1e-2);
+        EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
     }
 }
 

From 7e57648ea22761f9e5cce2d5bba5b7b2ff71b331 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 13:09:39 +0400
Subject: [PATCH 081/155] FGDStatModel

---
 modules/gpu/src/cuda/fgd_bgfg.cu | 57 +++-----------------------------
 1 file changed, 5 insertions(+), 52 deletions(-)

diff --git a/modules/gpu/src/cuda/fgd_bgfg.cu b/modules/gpu/src/cuda/fgd_bgfg.cu
index 6040d021b..6361e1811 100644
--- a/modules/gpu/src/cuda/fgd_bgfg.cu
+++ b/modules/gpu/src/cuda/fgd_bgfg.cu
@@ -46,6 +46,8 @@
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
+#include "opencv2/gpu/device/functional.hpp"
 #include "fgd_bgfg_common.hpp"
 
 using namespace cv::gpu;
@@ -181,57 +183,8 @@ namespace bgfg
         __shared__ unsigned int data1[MERGE_THREADBLOCK_SIZE];
         __shared__ unsigned int data2[MERGE_THREADBLOCK_SIZE];
 
-        data0[threadIdx.x] = sum0;
-        data1[threadIdx.x] = sum1;
-        data2[threadIdx.x] = sum2;
-        __syncthreads();
-
-        if (threadIdx.x < 128)
-        {
-            data0[threadIdx.x] = sum0 += data0[threadIdx.x + 128];
-            data1[threadIdx.x] = sum1 += data1[threadIdx.x + 128];
-            data2[threadIdx.x] = sum2 += data2[threadIdx.x + 128];
-        }
-        __syncthreads();
-
-        if (threadIdx.x < 64)
-        {
-            data0[threadIdx.x] = sum0 += data0[threadIdx.x + 64];
-            data1[threadIdx.x] = sum1 += data1[threadIdx.x + 64];
-            data2[threadIdx.x] = sum2 += data2[threadIdx.x + 64];
-        }
-        __syncthreads();
-
-        if (threadIdx.x < 32)
-        {
-            volatile unsigned int* vdata0 = data0;
-            volatile unsigned int* vdata1 = data1;
-            volatile unsigned int* vdata2 = data2;
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 32];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 32];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 32];
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 16];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 16];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 16];
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 8];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 8];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 8];
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 4];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 4];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 4];
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 2];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 2];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 2];
-
-            vdata0[threadIdx.x] = sum0 += vdata0[threadIdx.x + 1];
-            vdata1[threadIdx.x] = sum1 += vdata1[threadIdx.x + 1];
-            vdata2[threadIdx.x] = sum2 += vdata2[threadIdx.x + 1];
-        }
+        plus<unsigned int> op;
+        reduce<MERGE_THREADBLOCK_SIZE>(smem_tuple(data0, data1, data2), thrust::tie(sum0, sum1, sum2), threadIdx.x, thrust::make_tuple(op, op, op));
 
         if(threadIdx.x == 0)
         {
@@ -845,4 +798,4 @@ namespace bgfg
     template void updateBackgroundModel_gpu<uchar4, uchar4, uchar4>(PtrStepSzb prevFrame, PtrStepSzb curFrame, PtrStepSzb Ftd, PtrStepSzb Fbd, PtrStepSzb foreground, PtrStepSzb background, int deltaC, int deltaCC, float alpha1, float alpha2, float alpha3, int N1c, int N1cc, int N2c, int N2cc, float T, cudaStream_t stream);
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 0ddd16cf78229ceaaeaa5fb5a226a877cfc8feb8 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 13:16:47 +0400
Subject: [PATCH 082/155] calcHist & equalizeHist

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   2 -
 modules/gpu/perf/perf_imgproc.cpp       |   5 +-
 modules/gpu/src/cuda/hist.cu            | 273 +++++++++---------------
 modules/gpu/src/imgproc.cpp             |  50 +----
 4 files changed, 114 insertions(+), 216 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 4396a0a10..4aed05cae 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1028,11 +1028,9 @@ CV_EXPORTS void histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels
 //! Calculates histogram for 8u one channel image
 //! Output hist will have one row, 256 cols and CV32SC1 type.
 CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, Stream& stream = Stream::Null());
-CV_EXPORTS void calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
 
 //! normalizes the grayscale image brightness and contrast by normalizing its histogram
 CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream = Stream::Null());
-CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream = Stream::Null());
 CV_EXPORTS void equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& stream = Stream::Null());
 
 //////////////////////////////// StereoBM_GPU ////////////////////////////////
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 30377e148..a4e199bc7 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -581,13 +581,12 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
     {
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_hist;
-        cv::gpu::GpuMat d_buf;
 
-        cv::gpu::calcHist(d_src, d_hist, d_buf);
+        cv::gpu::calcHist(d_src, d_hist);
 
         TEST_CYCLE()
         {
-            cv::gpu::calcHist(d_src, d_hist, d_buf);
+            cv::gpu::calcHist(d_src, d_hist);
         }
 
         GPU_SANITY_CHECK(d_hist);
diff --git a/modules/gpu/src/cuda/hist.cu b/modules/gpu/src/cuda/hist.cu
index 3a2b59b85..2adc5d5b4 100644
--- a/modules/gpu/src/cuda/hist.cu
+++ b/modules/gpu/src/cuda/hist.cu
@@ -43,182 +43,115 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
-#include "opencv2/gpu/device/utility.hpp"
-#include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/emulation.hpp"
+#include "opencv2/gpu/device/transform.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
+{
+    __global__ void histogram256(const uchar* src, int cols, int rows, size_t step, int* hist)
+    {
+        __shared__ int shist[256];
+
+        const int y = blockIdx.x * blockDim.y + threadIdx.y;
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+
+        shist[tid] = 0;
+        __syncthreads();
+
+        if (y < rows)
+        {
+            const unsigned int* rowPtr = (const unsigned int*) (src + y * step);
+
+            const int cols_4 = cols / 4;
+            for (int x = threadIdx.x; x < cols_4; x += blockDim.x)
+            {
+                unsigned int data = rowPtr[x];
+
+                Emulation::smem::atomicAdd(&shist[(data >>  0) & 0xFFU], 1);
+                Emulation::smem::atomicAdd(&shist[(data >>  8) & 0xFFU], 1);
+                Emulation::smem::atomicAdd(&shist[(data >> 16) & 0xFFU], 1);
+                Emulation::smem::atomicAdd(&shist[(data >> 24) & 0xFFU], 1);
+            }
+
+            if (cols % 4 != 0 && threadIdx.x == 0)
+            {
+                for (int x = cols_4 * 4; x < cols; ++x)
+                {
+                    unsigned int data = ((const uchar*)rowPtr)[x];
+                    Emulation::smem::atomicAdd(&shist[data], 1);
+                }
+            }
+        }
+
+        __syncthreads();
+
+        const int histVal = shist[tid];
+        if (histVal > 0)
+            ::atomicAdd(hist + tid, histVal);
+    }
+}
+
+namespace hist
+{
+    void histogram256(PtrStepSzb src, int* hist, cudaStream_t stream)
+    {
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(src.rows, block.y));
+
+        ::histogram256<<<grid, block, 0, stream>>>(src.data, src.cols, src.rows, src.step, hist);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+namespace
+{
+    __constant__ int c_lut[256];
+
+    struct EqualizeHist : unary_function<uchar, uchar>
+    {
+        float scale;
+
+        __host__ EqualizeHist(float _scale) : scale(_scale) {}
+
+        __device__ __forceinline__ uchar operator ()(uchar val) const
+        {
+            const int lut = c_lut[val];
+            return __float2int_rn(scale * lut);
+        }
+    };
+}
 
 namespace cv { namespace gpu { namespace device
 {
-    #define UINT_BITS 32U
-
-    //Warps == subhistograms per threadblock
-    #define WARP_COUNT 6
-
-    //Threadblock size
-    #define HISTOGRAM256_THREADBLOCK_SIZE (WARP_COUNT * OPENCV_GPU_WARP_SIZE)
-    #define HISTOGRAM256_BIN_COUNT 256
-
-    //Shared memory per threadblock
-    #define HISTOGRAM256_THREADBLOCK_MEMORY (WARP_COUNT * HISTOGRAM256_BIN_COUNT)
-
-    #define PARTIAL_HISTOGRAM256_COUNT 240
-
-    #define MERGE_THREADBLOCK_SIZE 256
-
-    #define USE_SMEM_ATOMICS (defined (__CUDA_ARCH__) && (__CUDA_ARCH__ >= 120))
-
-    namespace hist
+    template <> struct TransformFunctorTraits<EqualizeHist> : DefaultTransformFunctorTraits<EqualizeHist>
     {
-        #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)
-        {
-            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);
-        }
-
-        __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)
-        {
-            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)
-            {
-                __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]);
-        }
-
-        void histogram256_gpu(PtrStepSzb src, int* hist, uint* buf, cudaStream_t stream)
-        {
-            histogram256<<<PARTIAL_HISTOGRAM256_COUNT, HISTOGRAM256_THREADBLOCK_SIZE, 0, stream>>>(
-                PtrStepSz<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 PtrStepSzb 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 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(PtrStepSzb src, PtrStepSzb dst, const int* lut, cudaStream_t stream)
-        {
-            dim3 block(16, 16);
-            dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
+        enum { smart_shift = 4 };
+    };
+}}}
 
+namespace hist
+{
+    void equalizeHist(PtrStepSzb src, PtrStepSzb dst, const int* lut, cudaStream_t stream)
+    {
+        if (stream == 0)
             cudaSafeCall( cudaMemcpyToSymbol(c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpyToSymbolAsync(c_lut, lut, 256 * sizeof(int), 0, cudaMemcpyDeviceToDevice, stream) );
 
-            equalizeHist<<<grid, block, 0, stream>>>(src, dst);
-            cudaSafeCall( cudaGetLastError() );
+        const float scale = 255.0f / (src.cols * src.rows);
 
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    } // namespace hist
-}}} // namespace cv { namespace gpu { namespace device
+        transform(src, dst, EqualizeHist(scale), WithOutMask(), stream);
+    }
+}
 
-
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index b733faf5d..b216de874 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -71,9 +71,7 @@ void cv::gpu::histRange(const GpuMat&, GpuMat&, const GpuMat&, GpuMat&, Stream&)
 void cv::gpu::histRange(const GpuMat&, GpuMat*, const GpuMat*, Stream&) { throw_nogpu(); }
 void cv::gpu::histRange(const GpuMat&, GpuMat*, const GpuMat*, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::calcHist(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
-void cv::gpu::calcHist(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
-void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::equalizeHist(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 void cv::gpu::cornerHarris(const GpuMat&, GpuMat&, int, int, double, int) { throw_nogpu(); }
 void cv::gpu::cornerHarris(const GpuMat&, GpuMat&, GpuMat&, GpuMat&, int, int, double, int) { throw_nogpu(); }
@@ -989,36 +987,20 @@ void cv::gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4
     hist_callers[src.depth()](src, hist, levels, buf, StreamAccessor::getStream(stream));
 }
 
-namespace cv { namespace gpu { namespace device
+namespace hist
 {
-    namespace hist
-    {
-        void histogram256_gpu(PtrStepSzb src, int* hist, unsigned int* buf, cudaStream_t stream);
-
-        const int PARTIAL_HISTOGRAM256_COUNT = 240;
-        const int HISTOGRAM256_BIN_COUNT     = 256;
-
-        void equalizeHist_gpu(PtrStepSzb src, PtrStepSzb dst, const int* lut, cudaStream_t stream);
-    }
-}}}
+    void histogram256(PtrStepSzb src, int* hist, cudaStream_t stream);
+    void equalizeHist(PtrStepSzb src, PtrStepSzb dst, const int* lut, cudaStream_t stream);
+}
 
 void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, Stream& stream)
 {
-    GpuMat buf;
-    calcHist(src, hist, buf, stream);
-}
-
-void cv::gpu::calcHist(const GpuMat& src, GpuMat& hist, GpuMat& buf, Stream& stream)
-{
-    using namespace ::cv::gpu::device::hist;
-
     CV_Assert(src.type() == CV_8UC1);
 
     hist.create(1, 256, CV_32SC1);
+    hist.setTo(Scalar::all(0));
 
-    ensureSizeIsEnough(1, PARTIAL_HISTOGRAM256_COUNT * HISTOGRAM256_BIN_COUNT, CV_32SC1, buf);
-
-    histogram256_gpu(src, hist.ptr<int>(), buf.ptr<unsigned int>(), StreamAccessor::getStream(stream));
+    hist::histogram256(src, hist.ptr<int>(), StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream)
@@ -1028,16 +1010,8 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, Stream& stream)
     equalizeHist(src, dst, hist, buf, stream);
 }
 
-void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, Stream& stream)
-{
-    GpuMat buf;
-    equalizeHist(src, dst, hist, buf, stream);
-}
-
 void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat& buf, Stream& s)
 {
-    using namespace ::cv::gpu::device::hist;
-
     CV_Assert(src.type() == CV_8UC1);
 
     dst.create(src.size(), src.type());
@@ -1045,15 +1019,12 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat&
     int intBufSize;
     nppSafeCall( nppsIntegralGetBufferSize_32s(256, &intBufSize) );
 
-    int bufSize = static_cast<int>(std::max(256 * 240 * sizeof(int), intBufSize + 256 * sizeof(int)));
+    ensureSizeIsEnough(1, intBufSize + 256 * sizeof(int), CV_8UC1, buf);
 
-    ensureSizeIsEnough(1, bufSize, CV_8UC1, buf);
-
-    GpuMat histBuf(1, 256 * 240, CV_32SC1, buf.ptr());
     GpuMat intBuf(1, intBufSize, CV_8UC1, buf.ptr());
     GpuMat lut(1, 256, CV_32S, buf.ptr() + intBufSize);
 
-    calcHist(src, hist, histBuf, s);
+    calcHist(src, hist, s);
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
@@ -1061,10 +1032,7 @@ void cv::gpu::equalizeHist(const GpuMat& src, GpuMat& dst, GpuMat& hist, GpuMat&
 
     nppSafeCall( nppsIntegral_32s(hist.ptr<Npp32s>(), lut.ptr<Npp32s>(), 256, intBuf.ptr<Npp8u>()) );
 
-    if (stream == 0)
-        cudaSafeCall( cudaDeviceSynchronize() );
-
-    equalizeHist_gpu(src, dst, lut.ptr<int>(), stream);
+    hist::equalizeHist(src, dst, lut.ptr<int>(), stream);
 }
 
 ////////////////////////////////////////////////////////////////////////

From 0e339dd13741a52e29cf65ee4e155e114218af4b Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 13:19:48 +0400
Subject: [PATCH 083/155] hog

---
 modules/gpu/src/cuda/hog.cu | 179 ++++++++++++------------------------
 1 file changed, 60 insertions(+), 119 deletions(-)

diff --git a/modules/gpu/src/cuda/hog.cu b/modules/gpu/src/cuda/hog.cu
index 953fdec1d..6a7e927d1 100644
--- a/modules/gpu/src/cuda/hog.cu
+++ b/modules/gpu/src/cuda/hog.cu
@@ -42,7 +42,10 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/warp_shuffle.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -226,29 +229,30 @@ namespace cv { namespace gpu { namespace device
 
 
         template<int size>
-        __device__ float reduce_smem(volatile float* smem)
+        __device__ float reduce_smem(float* smem, float val)
         {
             unsigned int tid = threadIdx.x;
-            float sum = smem[tid];
+            float sum = val;
 
-            if (size >= 512) { if (tid < 256) smem[tid] = sum = sum + smem[tid + 256]; __syncthreads(); }
-            if (size >= 256) { if (tid < 128) smem[tid] = sum = sum + smem[tid + 128]; __syncthreads(); }
-            if (size >= 128) { if (tid < 64) smem[tid] = sum = sum + smem[tid + 64]; __syncthreads(); }
+            reduce<size>(smem, sum, tid, plus<float>());
 
-            if (tid < 32)
+            if (size == 32)
             {
-                if (size >= 64) smem[tid] = sum = sum + smem[tid + 32];
-                if (size >= 32) smem[tid] = sum = sum + smem[tid + 16];
-                if (size >= 16) smem[tid] = sum = sum + smem[tid + 8];
-                if (size >= 8) smem[tid] = sum = sum + smem[tid + 4];
-                if (size >= 4) smem[tid] = sum = sum + smem[tid + 2];
-                if (size >= 2) smem[tid] = sum = sum + smem[tid + 1];
+            #if __CUDA_ARCH__ >= 300
+                return shfl(sum, 0);
+            #else
+                return smem[0];
+            #endif
             }
 
-            __syncthreads();
-            sum = smem[0];
+        #if __CUDA_ARCH__ >= 300
+            if (threadIdx.x == 0)
+                smem[0] = sum;
+        #endif
 
-            return sum;
+            __syncthreads();
+
+            return smem[0];
         }
 
 
@@ -272,19 +276,13 @@ namespace cv { namespace gpu { namespace device
             if (threadIdx.x < block_hist_size)
                 elem = hist[0];
 
-            squares[threadIdx.x] = elem * elem;
-
-            __syncthreads();
-            float sum = reduce_smem<nthreads>(squares);
+            float sum = reduce_smem<nthreads>(squares, elem * elem);
 
             float scale = 1.0f / (::sqrtf(sum) + 0.1f * block_hist_size);
             elem = ::min(elem * scale, threshold);
 
-            __syncthreads();
-            squares[threadIdx.x] = elem * elem;
+            sum = reduce_smem<nthreads>(squares, elem * elem);
 
-            __syncthreads();
-            sum = reduce_smem<nthreads>(squares);
             scale = 1.0f / (::sqrtf(sum) + 1e-3f);
 
             if (threadIdx.x < block_hist_size)
@@ -330,65 +328,36 @@ namespace cv { namespace gpu { namespace device
 
        // return confidence values not just positive location
        template <int nthreads, // Number of threads per one histogram block
-                           int nblocks> // Number of histogram block processed by single GPU thread block
+                 int nblocks>  // Number of histogram block processed by single GPU thread block
        __global__ void compute_confidence_hists_kernel_many_blocks(const int img_win_width, const int img_block_width,
                                                                                                            const int win_block_stride_x, const int win_block_stride_y,
                                                                                                            const float* block_hists, const float* coefs,
                                                                                                            float free_coef, float threshold, float* confidences)
        {
-               const int win_x = threadIdx.z;
-               if (blockIdx.x * blockDim.z + win_x >= img_win_width)
-                       return;
+           const int win_x = threadIdx.z;
+           if (blockIdx.x * blockDim.z + win_x >= img_win_width)
+                   return;
 
-               const float* hist = block_hists + (blockIdx.y * win_block_stride_y * img_block_width +
-                                                                                    blockIdx.x * win_block_stride_x * blockDim.z + win_x) *
-                                                                                   cblock_hist_size;
+           const float* hist = block_hists + (blockIdx.y * win_block_stride_y * img_block_width +
+                                                                                blockIdx.x * win_block_stride_x * blockDim.z + win_x) *
+                                                                               cblock_hist_size;
 
-               float product = 0.f;
-               for (int i = threadIdx.x; i < cdescr_size; i += nthreads)
-               {
-                       int offset_y = i / cdescr_width;
-                       int offset_x = i - offset_y * cdescr_width;
-                       product += coefs[i] * hist[offset_y * img_block_width * cblock_hist_size + offset_x];
-               }
+           float product = 0.f;
+           for (int i = threadIdx.x; i < cdescr_size; i += nthreads)
+           {
+                   int offset_y = i / cdescr_width;
+                   int offset_x = i - offset_y * cdescr_width;
+                   product += coefs[i] * hist[offset_y * img_block_width * cblock_hist_size + offset_x];
+           }
 
-               __shared__ float products[nthreads * nblocks];
+           __shared__ float products[nthreads * nblocks];
 
-               const int tid = threadIdx.z * nthreads + threadIdx.x;
-               products[tid] = product;
+           const int tid = threadIdx.z * nthreads + threadIdx.x;
 
-               __syncthreads();
+           reduce<nthreads>(products, product, tid, plus<float>());
 
-               if (nthreads >= 512)
-               {
-                       if (threadIdx.x < 256) products[tid] = product = product + products[tid + 256];
-                       __syncthreads();
-               }
-               if (nthreads >= 256)
-               {
-                       if (threadIdx.x < 128) products[tid] = product = product + products[tid + 128];
-                       __syncthreads();
-               }
-               if (nthreads >= 128)
-               {
-                       if (threadIdx.x < 64) products[tid] = product = product + products[tid + 64];
-                       __syncthreads();
-               }
-
-               if (threadIdx.x < 32)
-               {
-                       volatile float* smem = products;
-                       if (nthreads >= 64) smem[tid] = product = product + smem[tid + 32];
-                       if (nthreads >= 32) smem[tid] = product = product + smem[tid + 16];
-                       if (nthreads >= 16) smem[tid] = product = product + smem[tid + 8];
-                       if (nthreads >= 8) smem[tid] = product = product + smem[tid + 4];
-                       if (nthreads >= 4) smem[tid] = product = product + smem[tid + 2];
-                       if (nthreads >= 2) smem[tid] = product = product + smem[tid + 1];
-               }
-
-               if (threadIdx.x == 0)
-                       confidences[blockIdx.y * img_win_width + blockIdx.x * blockDim.z + win_x]
-                               = (float)(product + free_coef);
+           if (threadIdx.x == 0)
+               confidences[blockIdx.y * img_win_width + blockIdx.x * blockDim.z + win_x] = product + free_coef;
 
        }
 
@@ -396,32 +365,32 @@ namespace cv { namespace gpu { namespace device
                                                int win_stride_y, int win_stride_x, int height, int width, float* block_hists,
                                                float* coefs, float free_coef, float threshold, float *confidences)
        {
-               const int nthreads = 256;
-               const int nblocks = 1;
+           const int nthreads = 256;
+           const int nblocks = 1;
 
-               int win_block_stride_x = win_stride_x / block_stride_x;
-               int win_block_stride_y = win_stride_y / block_stride_y;
-               int img_win_width = (width - win_width + win_stride_x) / win_stride_x;
-               int img_win_height = (height - win_height + win_stride_y) / win_stride_y;
+           int win_block_stride_x = win_stride_x / block_stride_x;
+           int win_block_stride_y = win_stride_y / block_stride_y;
+           int img_win_width = (width - win_width + win_stride_x) / win_stride_x;
+           int img_win_height = (height - win_height + win_stride_y) / win_stride_y;
 
-               dim3 threads(nthreads, 1, nblocks);
-               dim3 grid(divUp(img_win_width, nblocks), img_win_height);
+           dim3 threads(nthreads, 1, nblocks);
+           dim3 grid(divUp(img_win_width, nblocks), img_win_height);
 
-               cudaSafeCall(cudaFuncSetCacheConfig(compute_confidence_hists_kernel_many_blocks<nthreads, nblocks>,
-                                                                                       cudaFuncCachePreferL1));
+           cudaSafeCall(cudaFuncSetCacheConfig(compute_confidence_hists_kernel_many_blocks<nthreads, nblocks>,
+                                                                                   cudaFuncCachePreferL1));
 
-               int img_block_width = (width - CELLS_PER_BLOCK_X * CELL_WIDTH + block_stride_x) /
-                                                           block_stride_x;
-               compute_confidence_hists_kernel_many_blocks<nthreads, nblocks><<<grid, threads>>>(
-                       img_win_width, img_block_width, win_block_stride_x, win_block_stride_y,
-                       block_hists, coefs, free_coef, threshold, confidences);
-               cudaSafeCall(cudaThreadSynchronize());
+           int img_block_width = (width - CELLS_PER_BLOCK_X * CELL_WIDTH + block_stride_x) /
+                                                       block_stride_x;
+           compute_confidence_hists_kernel_many_blocks<nthreads, nblocks><<<grid, threads>>>(
+                   img_win_width, img_block_width, win_block_stride_x, win_block_stride_y,
+                   block_hists, coefs, free_coef, threshold, confidences);
+           cudaSafeCall(cudaThreadSynchronize());
        }
 
 
 
         template <int nthreads, // Number of threads per one histogram block
-                  int nblocks> // Number of histogram block processed by single GPU thread block
+                  int nblocks>  // Number of histogram block processed by single GPU thread block
         __global__ void classify_hists_kernel_many_blocks(const int img_win_width, const int img_block_width,
                                                           const int win_block_stride_x, const int win_block_stride_y,
                                                           const float* block_hists, const float* coefs,
@@ -446,36 +415,8 @@ namespace cv { namespace gpu { namespace device
             __shared__ float products[nthreads * nblocks];
 
             const int tid = threadIdx.z * nthreads + threadIdx.x;
-            products[tid] = product;
 
-            __syncthreads();
-
-            if (nthreads >= 512)
-            {
-                if (threadIdx.x < 256) products[tid] = product = product + products[tid + 256];
-                __syncthreads();
-            }
-            if (nthreads >= 256)
-            {
-                if (threadIdx.x < 128) products[tid] = product = product + products[tid + 128];
-                __syncthreads();
-            }
-            if (nthreads >= 128)
-            {
-                if (threadIdx.x < 64) products[tid] = product = product + products[tid + 64];
-                __syncthreads();
-            }
-
-            if (threadIdx.x < 32)
-            {
-                volatile float* smem = products;
-                if (nthreads >= 64) smem[tid] = product = product + smem[tid + 32];
-                if (nthreads >= 32) smem[tid] = product = product + smem[tid + 16];
-                if (nthreads >= 16) smem[tid] = product = product + smem[tid + 8];
-                if (nthreads >= 8) smem[tid] = product = product + smem[tid + 4];
-                if (nthreads >= 4) smem[tid] = product = product + smem[tid + 2];
-                if (nthreads >= 2) smem[tid] = product = product + smem[tid + 1];
-            }
+            reduce<nthreads>(products, product, tid, plus<float>());
 
             if (threadIdx.x == 0)
                 labels[blockIdx.y * img_win_width + blockIdx.x * blockDim.z + win_x] = (product + free_coef >= threshold);
@@ -868,4 +809,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 1b571bde10183b8270e8b46ab0d296ae55a6d39e Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:08:46 +0400
Subject: [PATCH 084/155] StereoConstantSpaceBP

---
 modules/gpu/src/cuda/stereocsbp.cu | 44 ++++++------------------------
 1 file changed, 8 insertions(+), 36 deletions(-)

diff --git a/modules/gpu/src/cuda/stereocsbp.cu b/modules/gpu/src/cuda/stereocsbp.cu
index 1c95ed9e1..7b76f478b 100644
--- a/modules/gpu/src/cuda/stereocsbp.cu
+++ b/modules/gpu/src/cuda/stereocsbp.cu
@@ -42,9 +42,11 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/limits.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
+#include "opencv2/gpu/device/functional.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -297,28 +299,13 @@ namespace cv { namespace gpu { namespace device
                 }
 
                 extern __shared__ float smem[];
-                float* dline = smem + winsz * threadIdx.z;
 
-                dline[tid] = val;
-
-                __syncthreads();
-
-                if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } __syncthreads(); }
-                if (winsz >= 128) { if (tid <  64) { dline[tid] += dline[tid + 64]; } __syncthreads(); }
-
-                volatile float* vdline = smem + winsz * threadIdx.z;
-
-                if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32];
-                if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16];
-                if (winsz >= 16) if (tid <  8) vdline[tid] += vdline[tid + 8];
-                if (winsz >=  8) if (tid <  4) vdline[tid] += vdline[tid + 4];
-                if (winsz >=  4) if (tid <  2) vdline[tid] += vdline[tid + 2];
-                if (winsz >=  2) if (tid <  1) vdline[tid] += vdline[tid + 1];
+                reduce<winsz>(smem + winsz * threadIdx.z, val, tid, plus<float>());
 
                 T* data_cost = (T*)ctemp + y_out * cmsg_step + x_out;
 
                 if (tid == 0)
-                    data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
+                    data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
             }
         }
 
@@ -496,26 +483,11 @@ namespace cv { namespace gpu { namespace device
                 }
 
                 extern __shared__ float smem[];
-                float* dline = smem + winsz * threadIdx.z;
 
-                dline[tid] = val;
-
-                __syncthreads();
-
-                if (winsz >= 256) { if (tid < 128) { dline[tid] += dline[tid + 128]; } __syncthreads(); }
-                if (winsz >= 128) { if (tid <  64) { dline[tid] += dline[tid +  64]; } __syncthreads(); }
-
-                volatile float* vdline = smem + winsz * threadIdx.z;
-
-                if (winsz >= 64) if (tid < 32) vdline[tid] += vdline[tid + 32];
-                if (winsz >= 32) if (tid < 16) vdline[tid] += vdline[tid + 16];
-                if (winsz >= 16) if (tid <  8) vdline[tid] += vdline[tid + 8];
-                if (winsz >=  8) if (tid <  4) vdline[tid] += vdline[tid + 4];
-                if (winsz >=  4) if (tid <  2) vdline[tid] += vdline[tid + 2];
-                if (winsz >=  2) if (tid <  1) vdline[tid] += vdline[tid + 1];
+                reduce<winsz>(smem + winsz * threadIdx.z, val, tid, plus<float>());
 
                 if (tid == 0)
-                    data_cost[cdisp_step1 * d] = saturate_cast<T>(dline[0]);
+                    data_cost[cdisp_step1 * d] = saturate_cast<T>(val);
             }
         }
 
@@ -889,4 +861,4 @@ namespace cv { namespace gpu { namespace device
     } // namespace stereocsbp
 }}} // namespace cv { namespace gpu { namespace device {
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 1f1e24be3c475054f168bf2f776bd597e79d4ca4 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:12:27 +0400
Subject: [PATCH 085/155] PyrLKOpticalFlow

---
 modules/gpu/src/cuda/pyrlk.cu | 968 +++++++++++++++-------------------
 modules/gpu/src/pyrlk.cpp     |  35 +-
 2 files changed, 440 insertions(+), 563 deletions(-)

diff --git a/modules/gpu/src/cuda/pyrlk.cu b/modules/gpu/src/cuda/pyrlk.cu
index 811c3b90b..c0f54bd33 100644
--- a/modules/gpu/src/cuda/pyrlk.cu
+++ b/modules/gpu/src/cuda/pyrlk.cu
@@ -52,244 +52,187 @@
 #include "opencv2/gpu/device/functional.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 
-namespace cv { namespace gpu { namespace device
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
 {
-    namespace pyrlk
+    __constant__ int c_winSize_x;
+    __constant__ int c_winSize_y;
+    __constant__ int c_halfWin_x;
+    __constant__ int c_halfWin_y;
+    __constant__ int c_iters;
+
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_If(false, cudaFilterModeLinear, cudaAddressModeClamp);
+    texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_If4(false, cudaFilterModeLinear, cudaAddressModeClamp);
+    texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_Ib(false, cudaFilterModePoint, cudaAddressModeClamp);
+
+    texture<float, cudaTextureType2D, cudaReadModeElementType> tex_Jf(false, cudaFilterModeLinear, cudaAddressModeClamp);
+    texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_Jf4(false, cudaFilterModeLinear, cudaAddressModeClamp);
+
+    template <int cn> struct Tex_I;
+    template <> struct Tex_I<1>
     {
-        __constant__ int c_winSize_x;
-        __constant__ int c_winSize_y;
-
-        __constant__ int c_halfWin_x;
-        __constant__ int c_halfWin_y;
-
-        __constant__ int c_iters;
-
-        void loadConstants(int2 winSize, int iters)
+        static __device__ __forceinline__ float read(float x, float y)
         {
-            cudaSafeCall( cudaMemcpyToSymbol(c_winSize_x, &winSize.x, sizeof(int)) );
-            cudaSafeCall( cudaMemcpyToSymbol(c_winSize_y, &winSize.y, sizeof(int)) );
+            return tex2D(tex_If, x, y);
+        }
+    };
+    template <> struct Tex_I<4>
+    {
+        static __device__ __forceinline__ float4 read(float x, float y)
+        {
+            return tex2D(tex_If4, x, y);
+        }
+    };
 
-            int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);
-            cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_x, &halfWin.x, sizeof(int)) );
-            cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_y, &halfWin.y, sizeof(int)) );
+    template <int cn> struct Tex_J;
+    template <> struct Tex_J<1>
+    {
+        static __device__ __forceinline__ float read(float x, float y)
+        {
+            return tex2D(tex_Jf, x, y);
+        }
+    };
+    template <> struct Tex_J<4>
+    {
+        static __device__ __forceinline__ float4 read(float x, float y)
+        {
+            return tex2D(tex_Jf4, x, y);
+        }
+    };
 
-            cudaSafeCall( cudaMemcpyToSymbol(c_iters, &iters, sizeof(int)) );
+    __device__ __forceinline__ void accum(float& dst, float val)
+    {
+        dst += val;
+    }
+    __device__ __forceinline__ void accum(float& dst, const float4& val)
+    {
+        dst += val.x + val.y + val.z;
+    }
+
+    __device__ __forceinline__ float abs_(float a)
+    {
+        return ::fabsf(a);
+    }
+    __device__ __forceinline__ float4 abs_(const float4& a)
+    {
+        return abs(a);
+    }
+
+    template <int cn, int PATCH_X, int PATCH_Y, bool calcErr>
+    __global__ void sparse(const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)
+    {
+    #if __CUDA_ARCH__ <= 110
+        const int BLOCK_SIZE = 128;
+    #else
+        const int BLOCK_SIZE = 256;
+    #endif
+
+        __shared__ float smem1[BLOCK_SIZE];
+        __shared__ float smem2[BLOCK_SIZE];
+        __shared__ float smem3[BLOCK_SIZE];
+
+        const unsigned int tid = threadIdx.y * blockDim.x + threadIdx.x;
+
+        float2 prevPt = prevPts[blockIdx.x];
+        prevPt.x *= (1.0f / (1 << level));
+        prevPt.y *= (1.0f / (1 << level));
+
+        if (prevPt.x < 0 || prevPt.x >= cols || prevPt.y < 0 || prevPt.y >= rows)
+        {
+            if (tid == 0 && level == 0)
+                status[blockIdx.x] = 0;
+
+            return;
         }
 
-        __device__ void reduce(float& val1, float& val2, float& val3, float* smem1, float* smem2, float* smem3, int tid)
+        prevPt.x -= c_halfWin_x;
+        prevPt.y -= c_halfWin_y;
+
+        // extract the patch from the first image, compute covariation matrix of derivatives
+
+        float A11 = 0;
+        float A12 = 0;
+        float A22 = 0;
+
+        typedef typename TypeVec<float, cn>::vec_type work_type;
+
+        work_type I_patch   [PATCH_Y][PATCH_X];
+        work_type dIdx_patch[PATCH_Y][PATCH_X];
+        work_type dIdy_patch[PATCH_Y][PATCH_X];
+
+        for (int yBase = threadIdx.y, i = 0; yBase < c_winSize_y; yBase += blockDim.y, ++i)
         {
-            smem1[tid] = val1;
-            smem2[tid] = val2;
-            smem3[tid] = val3;
-            __syncthreads();
-
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ > 110)
-            if (tid < 128)
+            for (int xBase = threadIdx.x, j = 0; xBase < c_winSize_x; xBase += blockDim.x, ++j)
             {
-                smem1[tid] = val1 += smem1[tid + 128];
-                smem2[tid] = val2 += smem2[tid + 128];
-                smem3[tid] = val3 += smem3[tid + 128];
-            }
-            __syncthreads();
-#endif
+                float x = prevPt.x + xBase + 0.5f;
+                float y = prevPt.y + yBase + 0.5f;
 
-            if (tid < 64)
-            {
-                smem1[tid] = val1 += smem1[tid + 64];
-                smem2[tid] = val2 += smem2[tid + 64];
-                smem3[tid] = val3 += smem3[tid + 64];
-            }
-            __syncthreads();
+                I_patch[i][j] = Tex_I<cn>::read(x, y);
 
-            if (tid < 32)
-            {
-                volatile float* vmem1 = smem1;
-                volatile float* vmem2 = smem2;
-                volatile float* vmem3 = smem3;
+                // Sharr Deriv
 
-                vmem1[tid] = val1 += vmem1[tid + 32];
-                vmem2[tid] = val2 += vmem2[tid + 32];
-                vmem3[tid] = val3 += vmem3[tid + 32];
+                work_type dIdx = 3.0f * Tex_I<cn>::read(x+1, y-1) + 10.0f * Tex_I<cn>::read(x+1, y) + 3.0f * Tex_I<cn>::read(x+1, y+1) -
+                                 (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x-1, y) + 3.0f * Tex_I<cn>::read(x-1, y+1));
 
-                vmem1[tid] = val1 += vmem1[tid + 16];
-                vmem2[tid] = val2 += vmem2[tid + 16];
-                vmem3[tid] = val3 += vmem3[tid + 16];
+                work_type dIdy = 3.0f * Tex_I<cn>::read(x-1, y+1) + 10.0f * Tex_I<cn>::read(x, y+1) + 3.0f * Tex_I<cn>::read(x+1, y+1) -
+                                (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x, y-1) + 3.0f * Tex_I<cn>::read(x+1, y-1));
 
-                vmem1[tid] = val1 += vmem1[tid + 8];
-                vmem2[tid] = val2 += vmem2[tid + 8];
-                vmem3[tid] = val3 += vmem3[tid + 8];
+                dIdx_patch[i][j] = dIdx;
+                dIdy_patch[i][j] = dIdy;
 
-                vmem1[tid] = val1 += vmem1[tid + 4];
-                vmem2[tid] = val2 += vmem2[tid + 4];
-                vmem3[tid] = val3 += vmem3[tid + 4];
-
-                vmem1[tid] = val1 += vmem1[tid + 2];
-                vmem2[tid] = val2 += vmem2[tid + 2];
-                vmem3[tid] = val3 += vmem3[tid + 2];
-
-                vmem1[tid] = val1 += vmem1[tid + 1];
-                vmem2[tid] = val2 += vmem2[tid + 1];
-                vmem3[tid] = val3 += vmem3[tid + 1];
+                accum(A11, dIdx * dIdx);
+                accum(A12, dIdx * dIdy);
+                accum(A22, dIdy * dIdy);
             }
         }
 
-        __device__ void reduce(float& val1, float& val2, float* smem1, float* smem2, int tid)
+        reduce<BLOCK_SIZE>(smem_tuple(smem1, smem2, smem3), thrust::tie(A11, A12, A22), tid, thrust::make_tuple(plus<float>(), plus<float>(), plus<float>()));
+
+    #if __CUDA_ARCH__ >= 300
+        if (tid == 0)
         {
-            smem1[tid] = val1;
-            smem2[tid] = val2;
-            __syncthreads();
+            smem1[0] = A11;
+            smem2[0] = A12;
+            smem3[0] = A22;
+        }
+    #endif
 
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ > 110)
-            if (tid < 128)
-            {
-                smem1[tid] = val1 += smem1[tid + 128];
-                smem2[tid] = val2 += smem2[tid + 128];
-            }
-            __syncthreads();
-#endif
+        __syncthreads();
 
-            if (tid < 64)
-            {
-                smem1[tid] = val1 += smem1[tid + 64];
-                smem2[tid] = val2 += smem2[tid + 64];
-            }
-            __syncthreads();
+        A11 = smem1[0];
+        A12 = smem2[0];
+        A22 = smem3[0];
 
-            if (tid < 32)
-            {
-                volatile float* vmem1 = smem1;
-                volatile float* vmem2 = smem2;
+        float D = A11 * A22 - A12 * A12;
 
-                vmem1[tid] = val1 += vmem1[tid + 32];
-                vmem2[tid] = val2 += vmem2[tid + 32];
+        if (D < numeric_limits<float>::epsilon())
+        {
+            if (tid == 0 && level == 0)
+                status[blockIdx.x] = 0;
 
-                vmem1[tid] = val1 += vmem1[tid + 16];
-                vmem2[tid] = val2 += vmem2[tid + 16];
-
-                vmem1[tid] = val1 += vmem1[tid + 8];
-                vmem2[tid] = val2 += vmem2[tid + 8];
-
-                vmem1[tid] = val1 += vmem1[tid + 4];
-                vmem2[tid] = val2 += vmem2[tid + 4];
-
-                vmem1[tid] = val1 += vmem1[tid + 2];
-                vmem2[tid] = val2 += vmem2[tid + 2];
-
-                vmem1[tid] = val1 += vmem1[tid + 1];
-                vmem2[tid] = val2 += vmem2[tid + 1];
-            }
+            return;
         }
 
-        __device__ void reduce(float& val1, float* smem1, int tid)
+        D = 1.f / D;
+
+        A11 *= D;
+        A12 *= D;
+        A22 *= D;
+
+        float2 nextPt = nextPts[blockIdx.x];
+        nextPt.x *= 2.f;
+        nextPt.y *= 2.f;
+
+        nextPt.x -= c_halfWin_x;
+        nextPt.y -= c_halfWin_y;
+
+        for (int k = 0; k < c_iters; ++k)
         {
-            smem1[tid] = val1;
-            __syncthreads();
-
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ > 110)
-            if (tid < 128)
-            {
-                smem1[tid] = val1 += smem1[tid + 128];
-            }
-            __syncthreads();
-#endif
-
-            if (tid < 64)
-            {
-                smem1[tid] = val1 += smem1[tid + 64];
-            }
-            __syncthreads();
-
-            if (tid < 32)
-            {
-                volatile float* vmem1 = smem1;
-
-                vmem1[tid] = val1 += vmem1[tid + 32];
-                vmem1[tid] = val1 += vmem1[tid + 16];
-                vmem1[tid] = val1 += vmem1[tid + 8];
-                vmem1[tid] = val1 += vmem1[tid + 4];
-                vmem1[tid] = val1 += vmem1[tid + 2];
-                vmem1[tid] = val1 += vmem1[tid + 1];
-            }
-        }
-
-        texture<float, cudaTextureType2D, cudaReadModeElementType> tex_If(false, cudaFilterModeLinear, cudaAddressModeClamp);
-        texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_If4(false, cudaFilterModeLinear, cudaAddressModeClamp);
-        texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_Ib(false, cudaFilterModePoint, cudaAddressModeClamp);
-
-        texture<float, cudaTextureType2D, cudaReadModeElementType> tex_Jf(false, cudaFilterModeLinear, cudaAddressModeClamp);
-        texture<float4, cudaTextureType2D, cudaReadModeElementType> tex_Jf4(false, cudaFilterModeLinear, cudaAddressModeClamp);
-
-        template <int cn> struct Tex_I;
-        template <> struct Tex_I<1>
-        {
-            static __device__ __forceinline__ float read(float x, float y)
-            {
-                return tex2D(tex_If, x, y);
-            }
-        };
-        template <> struct Tex_I<4>
-        {
-            static __device__ __forceinline__ float4 read(float x, float y)
-            {
-                return tex2D(tex_If4, x, y);
-            }
-        };
-
-        template <int cn> struct Tex_J;
-        template <> struct Tex_J<1>
-        {
-            static __device__ __forceinline__ float read(float x, float y)
-            {
-                return tex2D(tex_Jf, x, y);
-            }
-        };
-        template <> struct Tex_J<4>
-        {
-            static __device__ __forceinline__ float4 read(float x, float y)
-            {
-                return tex2D(tex_Jf4, x, y);
-            }
-        };
-
-        __device__ __forceinline__ void accum(float& dst, float val)
-        {
-            dst += val;
-        }
-        __device__ __forceinline__ void accum(float& dst, const float4& val)
-        {
-            dst += val.x + val.y + val.z;
-        }
-
-        __device__ __forceinline__ float abs_(float a)
-        {
-            return ::fabs(a);
-        }
-        __device__ __forceinline__ float4 abs_(const float4& a)
-        {
-            return abs(a);
-        }
-
-        template <int cn, int PATCH_X, int PATCH_Y, bool calcErr>
-        __global__ void lkSparse(const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)
-        {
-#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ <= 110)
-            __shared__ float smem1[128];
-            __shared__ float smem2[128];
-            __shared__ float smem3[128];
-#else
-            __shared__ float smem1[256];
-            __shared__ float smem2[256];
-            __shared__ float smem3[256];
-#endif
-
-            const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-            float2 prevPt = prevPts[blockIdx.x];
-            prevPt.x *= (1.0f / (1 << level));
-            prevPt.y *= (1.0f / (1 << level));
-
-            if (prevPt.x < 0 || prevPt.x >= cols || prevPt.y < 0 || prevPt.y >= rows)
+            if (nextPt.x < -c_halfWin_x || nextPt.x >= cols || nextPt.y < -c_halfWin_y || nextPt.y >= rows)
             {
                 if (tid == 0 && level == 0)
                     status[blockIdx.x] = 0;
@@ -297,279 +240,183 @@ namespace cv { namespace gpu { namespace device
                 return;
             }
 
-            prevPt.x -= c_halfWin_x;
-            prevPt.y -= c_halfWin_y;
+            float b1 = 0;
+            float b2 = 0;
 
-            // extract the patch from the first image, compute covariation matrix of derivatives
-
-            float A11 = 0;
-            float A12 = 0;
-            float A22 = 0;
-
-            typedef typename TypeVec<float, cn>::vec_type work_type;
-
-            work_type I_patch   [PATCH_Y][PATCH_X];
-            work_type dIdx_patch[PATCH_Y][PATCH_X];
-            work_type dIdy_patch[PATCH_Y][PATCH_X];
-
-            for (int yBase = threadIdx.y, i = 0; yBase < c_winSize_y; yBase += blockDim.y, ++i)
+            for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)
             {
-                for (int xBase = threadIdx.x, j = 0; xBase < c_winSize_x; xBase += blockDim.x, ++j)
+                for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)
                 {
-                    float x = prevPt.x + xBase + 0.5f;
-                    float y = prevPt.y + yBase + 0.5f;
+                    work_type I_val = I_patch[i][j];
+                    work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);
 
-                    I_patch[i][j] = Tex_I<cn>::read(x, y);
+                    work_type diff = (J_val - I_val) * 32.0f;
 
-                    // Sharr Deriv
-
-                    work_type dIdx = 3.0f * Tex_I<cn>::read(x+1, y-1) + 10.0f * Tex_I<cn>::read(x+1, y) + 3.0f * Tex_I<cn>::read(x+1, y+1) -
-                                     (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x-1, y) + 3.0f * Tex_I<cn>::read(x-1, y+1));
-
-                    work_type dIdy = 3.0f * Tex_I<cn>::read(x-1, y+1) + 10.0f * Tex_I<cn>::read(x, y+1) + 3.0f * Tex_I<cn>::read(x+1, y+1) -
-                                    (3.0f * Tex_I<cn>::read(x-1, y-1) + 10.0f * Tex_I<cn>::read(x, y-1) + 3.0f * Tex_I<cn>::read(x+1, y-1));
-
-                    dIdx_patch[i][j] = dIdx;
-                    dIdy_patch[i][j] = dIdy;
-
-                    accum(A11, dIdx * dIdx);
-                    accum(A12, dIdx * dIdy);
-                    accum(A22, dIdy * dIdy);
+                    accum(b1, diff * dIdx_patch[i][j]);
+                    accum(b2, diff * dIdy_patch[i][j]);
                 }
             }
 
-            reduce(A11, A12, A22, smem1, smem2, smem3, tid);
-            __syncthreads();
-
-            A11 = smem1[0];
-            A12 = smem2[0];
-            A22 = smem3[0];
-
-            float D = A11 * A22 - A12 * A12;
-
-            if (D < numeric_limits<float>::epsilon())
-            {
-                if (tid == 0 && level == 0)
-                    status[blockIdx.x] = 0;
-
-                return;
-            }
-
-            D = 1.f / D;
-
-            A11 *= D;
-            A12 *= D;
-            A22 *= D;
-
-            float2 nextPt = nextPts[blockIdx.x];
-            nextPt.x *= 2.f;
-            nextPt.y *= 2.f;
-
-            nextPt.x -= c_halfWin_x;
-            nextPt.y -= c_halfWin_y;
-
-            for (int k = 0; k < c_iters; ++k)
-            {
-                if (nextPt.x < -c_halfWin_x || nextPt.x >= cols || nextPt.y < -c_halfWin_y || nextPt.y >= rows)
-                {
-                    if (tid == 0 && level == 0)
-                        status[blockIdx.x] = 0;
-
-                    return;
-                }
-
-                float b1 = 0;
-                float b2 = 0;
-
-                for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)
-                {
-                    for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)
-                    {
-                        work_type I_val = I_patch[i][j];
-                        work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);
-
-                        work_type diff = (J_val - I_val) * 32.0f;
-
-                        accum(b1, diff * dIdx_patch[i][j]);
-                        accum(b2, diff * dIdy_patch[i][j]);
-                    }
-                }
-
-                reduce(b1, b2, smem1, smem2, tid);
-                __syncthreads();
-
-                b1 = smem1[0];
-                b2 = smem2[0];
-
-                float2 delta;
-                delta.x = A12 * b2 - A22 * b1;
-                delta.y = A12 * b1 - A11 * b2;
-
-                nextPt.x += delta.x;
-                nextPt.y += delta.y;
-
-                if (::fabs(delta.x) < 0.01f && ::fabs(delta.y) < 0.01f)
-                    break;
-            }
-
-            float errval = 0;
-            if (calcErr)
-            {
-                for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)
-                {
-                    for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)
-                    {
-                        work_type I_val = I_patch[i][j];
-                        work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);
-
-                        work_type diff = J_val - I_val;
-
-                        accum(errval, abs_(diff));
-                    }
-                }
-
-                reduce(errval, smem1, tid);
-            }
+            reduce<BLOCK_SIZE>(smem_tuple(smem1, smem2), thrust::tie(b1, b2), tid, thrust::make_tuple(plus<float>(), plus<float>()));
 
+        #if __CUDA_ARCH__ >= 300
             if (tid == 0)
             {
-                nextPt.x += c_halfWin_x;
-                nextPt.y += c_halfWin_y;
-
-                nextPts[blockIdx.x] = nextPt;
-
-                if (calcErr)
-                    err[blockIdx.x] = static_cast<float>(errval) / (cn * c_winSize_x * c_winSize_y);
-            }
-        }
-
-        template <int cn, int PATCH_X, int PATCH_Y>
-        void lkSparse_caller(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-            int level, dim3 block, cudaStream_t stream)
-        {
-            dim3 grid(ptcount);
-
-            if (level == 0 && err)
-                lkSparse<cn, PATCH_X, PATCH_Y, true><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
-            else
-                lkSparse<cn, PATCH_X, PATCH_Y, false><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
-
-            cudaSafeCall( cudaGetLastError() );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-
-        void lkSparse1_gpu(PtrStepSzf I, PtrStepSzf J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-            int level, dim3 block, dim3 patch, cudaStream_t stream)
-        {
-            typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-                int level, dim3 block, cudaStream_t stream);
-
-            static const func_t funcs[5][5] =
-            {
-                {lkSparse_caller<1, 1, 1>, lkSparse_caller<1, 2, 1>, lkSparse_caller<1, 3, 1>, lkSparse_caller<1, 4, 1>, lkSparse_caller<1, 5, 1>},
-                {lkSparse_caller<1, 1, 2>, lkSparse_caller<1, 2, 2>, lkSparse_caller<1, 3, 2>, lkSparse_caller<1, 4, 2>, lkSparse_caller<1, 5, 2>},
-                {lkSparse_caller<1, 1, 3>, lkSparse_caller<1, 2, 3>, lkSparse_caller<1, 3, 3>, lkSparse_caller<1, 4, 3>, lkSparse_caller<1, 5, 3>},
-                {lkSparse_caller<1, 1, 4>, lkSparse_caller<1, 2, 4>, lkSparse_caller<1, 3, 4>, lkSparse_caller<1, 4, 4>, lkSparse_caller<1, 5, 4>},
-                {lkSparse_caller<1, 1, 5>, lkSparse_caller<1, 2, 5>, lkSparse_caller<1, 3, 5>, lkSparse_caller<1, 4, 5>, lkSparse_caller<1, 5, 5>}
-            };
-
-            bindTexture(&tex_If, I);
-            bindTexture(&tex_Jf, J);
-
-            funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,
-                level, block, stream);
-        }
-
-        void lkSparse4_gpu(PtrStepSz<float4> I, PtrStepSz<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-            int level, dim3 block, dim3 patch, cudaStream_t stream)
-        {
-            typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-                int level, dim3 block, cudaStream_t stream);
-
-            static const func_t funcs[5][5] =
-            {
-                {lkSparse_caller<4, 1, 1>, lkSparse_caller<4, 2, 1>, lkSparse_caller<4, 3, 1>, lkSparse_caller<4, 4, 1>, lkSparse_caller<4, 5, 1>},
-                {lkSparse_caller<4, 1, 2>, lkSparse_caller<4, 2, 2>, lkSparse_caller<4, 3, 2>, lkSparse_caller<4, 4, 2>, lkSparse_caller<4, 5, 2>},
-                {lkSparse_caller<4, 1, 3>, lkSparse_caller<4, 2, 3>, lkSparse_caller<4, 3, 3>, lkSparse_caller<4, 4, 3>, lkSparse_caller<4, 5, 3>},
-                {lkSparse_caller<4, 1, 4>, lkSparse_caller<4, 2, 4>, lkSparse_caller<4, 3, 4>, lkSparse_caller<4, 4, 4>, lkSparse_caller<4, 5, 4>},
-                {lkSparse_caller<4, 1, 5>, lkSparse_caller<4, 2, 5>, lkSparse_caller<4, 3, 5>, lkSparse_caller<4, 4, 5>, lkSparse_caller<4, 5, 5>}
-            };
-
-            bindTexture(&tex_If4, I);
-            bindTexture(&tex_Jf4, J);
-
-            funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,
-                level, block, stream);
-        }
-
-        template <bool calcErr>
-        __global__ void lkDense(PtrStepf u, PtrStepf v, const PtrStepf prevU, const PtrStepf prevV, PtrStepf err, const int rows, const int cols)
-        {
-            extern __shared__ int smem[];
-
-            const int patchWidth  = blockDim.x + 2 * c_halfWin_x;
-            const int patchHeight = blockDim.y + 2 * c_halfWin_y;
-
-            int* I_patch = smem;
-            int* dIdx_patch = I_patch + patchWidth * patchHeight;
-            int* dIdy_patch = dIdx_patch + patchWidth * patchHeight;
-
-            const int xBase = blockIdx.x * blockDim.x;
-            const int yBase = blockIdx.y * blockDim.y;
-
-            for (int i = threadIdx.y; i < patchHeight; i += blockDim.y)
-            {
-                for (int j = threadIdx.x; j < patchWidth; j += blockDim.x)
-                {
-                    float x = xBase - c_halfWin_x + j + 0.5f;
-                    float y = yBase - c_halfWin_y + i + 0.5f;
-
-                    I_patch[i * patchWidth + j] = tex2D(tex_Ib, x, y);
-
-                    // Sharr Deriv
-
-                    dIdx_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x+1, y-1) + 10 * tex2D(tex_Ib, x+1, y) + 3 * tex2D(tex_Ib, x+1, y+1) -
-                                                    (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x-1, y) + 3 * tex2D(tex_Ib, x-1, y+1));
-
-                    dIdy_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x-1, y+1) + 10 * tex2D(tex_Ib, x, y+1) + 3 * tex2D(tex_Ib, x+1, y+1) -
-                                                    (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x, y-1) + 3 * tex2D(tex_Ib, x+1, y-1));
-                }
+                smem1[0] = b1;
+                smem2[0] = b2;
             }
+        #endif
 
             __syncthreads();
 
-            const int x = xBase + threadIdx.x;
-            const int y = yBase + threadIdx.y;
+            b1 = smem1[0];
+            b2 = smem2[0];
 
-            if (x >= cols || y >= rows)
-                return;
+            float2 delta;
+            delta.x = A12 * b2 - A22 * b1;
+            delta.y = A12 * b1 - A11 * b2;
 
-            int A11i = 0;
-            int A12i = 0;
-            int A22i = 0;
+            nextPt.x += delta.x;
+            nextPt.y += delta.y;
 
-            for (int i = 0; i < c_winSize_y; ++i)
+            if (::fabs(delta.x) < 0.01f && ::fabs(delta.y) < 0.01f)
+                break;
+        }
+
+        float errval = 0;
+        if (calcErr)
+        {
+            for (int y = threadIdx.y, i = 0; y < c_winSize_y; y += blockDim.y, ++i)
             {
-                for (int j = 0; j < c_winSize_x; ++j)
+                for (int x = threadIdx.x, j = 0; x < c_winSize_x; x += blockDim.x, ++j)
                 {
-                    int dIdx = dIdx_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
-                    int dIdy = dIdy_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
+                    work_type I_val = I_patch[i][j];
+                    work_type J_val = Tex_J<cn>::read(nextPt.x + x + 0.5f, nextPt.y + y + 0.5f);
 
-                    A11i += dIdx * dIdx;
-                    A12i += dIdx * dIdy;
-                    A22i += dIdy * dIdy;
+                    work_type diff = J_val - I_val;
+
+                    accum(errval, abs_(diff));
                 }
             }
 
-            float A11 = A11i;
-            float A12 = A12i;
-            float A22 = A22i;
+            reduce<BLOCK_SIZE>(smem1, errval, tid, plus<float>());
+        }
 
-            float D = A11 * A22 - A12 * A12;
+        if (tid == 0)
+        {
+            nextPt.x += c_halfWin_x;
+            nextPt.y += c_halfWin_y;
 
-            if (D < numeric_limits<float>::epsilon())
+            nextPts[blockIdx.x] = nextPt;
+
+            if (calcErr)
+                err[blockIdx.x] = static_cast<float>(errval) / (cn * c_winSize_x * c_winSize_y);
+        }
+    }
+
+    template <int cn, int PATCH_X, int PATCH_Y>
+    void sparse_caller(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                       int level, dim3 block, cudaStream_t stream)
+    {
+        dim3 grid(ptcount);
+
+        if (level == 0 && err)
+            sparse<cn, PATCH_X, PATCH_Y, true><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
+        else
+            sparse<cn, PATCH_X, PATCH_Y, false><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template <bool calcErr>
+    __global__ void dense(PtrStepf u, PtrStepf v, const PtrStepf prevU, const PtrStepf prevV, PtrStepf err, const int rows, const int cols)
+    {
+        extern __shared__ int smem[];
+
+        const int patchWidth  = blockDim.x + 2 * c_halfWin_x;
+        const int patchHeight = blockDim.y + 2 * c_halfWin_y;
+
+        int* I_patch = smem;
+        int* dIdx_patch = I_patch + patchWidth * patchHeight;
+        int* dIdy_patch = dIdx_patch + patchWidth * patchHeight;
+
+        const int xBase = blockIdx.x * blockDim.x;
+        const int yBase = blockIdx.y * blockDim.y;
+
+        for (int i = threadIdx.y; i < patchHeight; i += blockDim.y)
+        {
+            for (int j = threadIdx.x; j < patchWidth; j += blockDim.x)
+            {
+                float x = xBase - c_halfWin_x + j + 0.5f;
+                float y = yBase - c_halfWin_y + i + 0.5f;
+
+                I_patch[i * patchWidth + j] = tex2D(tex_Ib, x, y);
+
+                // Sharr Deriv
+
+                dIdx_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x+1, y-1) + 10 * tex2D(tex_Ib, x+1, y) + 3 * tex2D(tex_Ib, x+1, y+1) -
+                                                (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x-1, y) + 3 * tex2D(tex_Ib, x-1, y+1));
+
+                dIdy_patch[i * patchWidth + j] = 3 * tex2D(tex_Ib, x-1, y+1) + 10 * tex2D(tex_Ib, x, y+1) + 3 * tex2D(tex_Ib, x+1, y+1) -
+                                                (3 * tex2D(tex_Ib, x-1, y-1) + 10 * tex2D(tex_Ib, x, y-1) + 3 * tex2D(tex_Ib, x+1, y-1));
+            }
+        }
+
+        __syncthreads();
+
+        const int x = xBase + threadIdx.x;
+        const int y = yBase + threadIdx.y;
+
+        if (x >= cols || y >= rows)
+            return;
+
+        int A11i = 0;
+        int A12i = 0;
+        int A22i = 0;
+
+        for (int i = 0; i < c_winSize_y; ++i)
+        {
+            for (int j = 0; j < c_winSize_x; ++j)
+            {
+                int dIdx = dIdx_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
+                int dIdy = dIdy_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
+
+                A11i += dIdx * dIdx;
+                A12i += dIdx * dIdy;
+                A22i += dIdy * dIdy;
+            }
+        }
+
+        float A11 = A11i;
+        float A12 = A12i;
+        float A22 = A22i;
+
+        float D = A11 * A22 - A12 * A12;
+
+        if (D < numeric_limits<float>::epsilon())
+        {
+            if (calcErr)
+                err(y, x) = numeric_limits<float>::max();
+
+            return;
+        }
+
+        D = 1.f / D;
+
+        A11 *= D;
+        A12 *= D;
+        A22 *= D;
+
+        float2 nextPt;
+        nextPt.x = x + prevU(y/2, x/2) * 2.0f;
+        nextPt.y = y + prevV(y/2, x/2) * 2.0f;
+
+        for (int k = 0; k < c_iters; ++k)
+        {
+            if (nextPt.x < 0 || nextPt.x >= cols || nextPt.y < 0 || nextPt.y >= rows)
             {
                 if (calcErr)
                     err(y, x) = numeric_limits<float>::max();
@@ -577,108 +424,145 @@ namespace cv { namespace gpu { namespace device
                 return;
             }
 
-            D = 1.f / D;
+            int b1 = 0;
+            int b2 = 0;
 
-            A11 *= D;
-            A12 *= D;
-            A22 *= D;
-
-            float2 nextPt;
-            nextPt.x = x + prevU(y/2, x/2) * 2.0f;
-            nextPt.y = y + prevV(y/2, x/2) * 2.0f;
-
-            for (int k = 0; k < c_iters; ++k)
+            for (int i = 0; i < c_winSize_y; ++i)
             {
-                if (nextPt.x < 0 || nextPt.x >= cols || nextPt.y < 0 || nextPt.y >= rows)
+                for (int j = 0; j < c_winSize_x; ++j)
                 {
-                    if (calcErr)
-                        err(y, x) = numeric_limits<float>::max();
+                    int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];
+                    int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);
 
-                    return;
+                    int diff = (J - I) * 32;
+
+                    int dIdx = dIdx_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
+                    int dIdy = dIdy_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
+
+                    b1 += diff * dIdx;
+                    b2 += diff * dIdy;
                 }
-
-                int b1 = 0;
-                int b2 = 0;
-
-                for (int i = 0; i < c_winSize_y; ++i)
-                {
-                    for (int j = 0; j < c_winSize_x; ++j)
-                    {
-                        int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];
-                        int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);
-
-                        int diff = (J - I) * 32;
-
-                        int dIdx = dIdx_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
-                        int dIdy = dIdy_patch[(threadIdx.y + i) * patchWidth + (threadIdx.x + j)];
-
-                        b1 += diff * dIdx;
-                        b2 += diff * dIdy;
-                    }
-                }
-
-                float2 delta;
-                delta.x = A12 * b2 - A22 * b1;
-                delta.y = A12 * b1 - A11 * b2;
-
-                nextPt.x += delta.x;
-                nextPt.y += delta.y;
-
-                if (::fabs(delta.x) < 0.01f && ::fabs(delta.y) < 0.01f)
-                    break;
             }
 
-            u(y, x) = nextPt.x - x;
-            v(y, x) = nextPt.y - y;
+            float2 delta;
+            delta.x = A12 * b2 - A22 * b1;
+            delta.y = A12 * b1 - A11 * b2;
 
-            if (calcErr)
-            {
-                int errval = 0;
+            nextPt.x += delta.x;
+            nextPt.y += delta.y;
 
-                for (int i = 0; i < c_winSize_y; ++i)
-                {
-                    for (int j = 0; j < c_winSize_x; ++j)
-                    {
-                        int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];
-                        int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);
-
-                        errval += ::abs(J - I);
-                    }
-                }
-
-                err(y, x) = static_cast<float>(errval) / (c_winSize_x * c_winSize_y);
-            }
+            if (::fabs(delta.x) < 0.01f && ::fabs(delta.y) < 0.01f)
+                break;
         }
 
-        void lkDense_gpu(PtrStepSzb I, PtrStepSzf J, PtrStepSzf u, PtrStepSzf v, PtrStepSzf prevU, PtrStepSzf prevV,
-                         PtrStepSzf err, int2 winSize, cudaStream_t stream)
+        u(y, x) = nextPt.x - x;
+        v(y, x) = nextPt.y - y;
+
+        if (calcErr)
         {
-            dim3 block(16, 16);
-            dim3 grid(divUp(I.cols, block.x), divUp(I.rows, block.y));
+            int errval = 0;
 
-            bindTexture(&tex_Ib, I);
-            bindTexture(&tex_Jf, J);
-
-            int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);
-            const int patchWidth  = block.x + 2 * halfWin.x;
-            const int patchHeight = block.y + 2 * halfWin.y;
-            size_t smem_size = 3 * patchWidth * patchHeight * sizeof(int);
-
-            if (err.data)
+            for (int i = 0; i < c_winSize_y; ++i)
             {
-                lkDense<true><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, err, I.rows, I.cols);
-                cudaSafeCall( cudaGetLastError() );
-            }
-            else
-            {
-                lkDense<false><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, PtrStepf(), I.rows, I.cols);
-                cudaSafeCall( cudaGetLastError() );
+                for (int j = 0; j < c_winSize_x; ++j)
+                {
+                    int I = I_patch[(threadIdx.y + i) * patchWidth + threadIdx.x + j];
+                    int J = tex2D(tex_Jf, nextPt.x - c_halfWin_x + j + 0.5f, nextPt.y - c_halfWin_y + i + 0.5f);
+
+                    errval += ::abs(J - I);
+                }
             }
 
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
+            err(y, x) = static_cast<float>(errval) / (c_winSize_x * c_winSize_y);
         }
     }
-}}}
+}
+
+namespace pyrlk
+{
+    void loadConstants(int2 winSize, int iters)
+    {
+        cudaSafeCall( cudaMemcpyToSymbol(c_winSize_x, &winSize.x, sizeof(int)) );
+        cudaSafeCall( cudaMemcpyToSymbol(c_winSize_y, &winSize.y, sizeof(int)) );
+
+        int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);
+        cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_x, &halfWin.x, sizeof(int)) );
+        cudaSafeCall( cudaMemcpyToSymbol(c_halfWin_y, &halfWin.y, sizeof(int)) );
+
+        cudaSafeCall( cudaMemcpyToSymbol(c_iters, &iters, sizeof(int)) );
+    }
+
+    void sparse1(PtrStepSzf I, PtrStepSzf J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                 int level, dim3 block, dim3 patch, cudaStream_t stream)
+    {
+        typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                               int level, dim3 block, cudaStream_t stream);
+
+        static const func_t funcs[5][5] =
+        {
+            {::sparse_caller<1, 1, 1>, ::sparse_caller<1, 2, 1>, ::sparse_caller<1, 3, 1>, ::sparse_caller<1, 4, 1>, ::sparse_caller<1, 5, 1>},
+            {::sparse_caller<1, 1, 2>, ::sparse_caller<1, 2, 2>, ::sparse_caller<1, 3, 2>, ::sparse_caller<1, 4, 2>, ::sparse_caller<1, 5, 2>},
+            {::sparse_caller<1, 1, 3>, ::sparse_caller<1, 2, 3>, ::sparse_caller<1, 3, 3>, ::sparse_caller<1, 4, 3>, ::sparse_caller<1, 5, 3>},
+            {::sparse_caller<1, 1, 4>, ::sparse_caller<1, 2, 4>, ::sparse_caller<1, 3, 4>, ::sparse_caller<1, 4, 4>, ::sparse_caller<1, 5, 4>},
+            {::sparse_caller<1, 1, 5>, ::sparse_caller<1, 2, 5>, ::sparse_caller<1, 3, 5>, ::sparse_caller<1, 4, 5>, ::sparse_caller<1, 5, 5>}
+        };
+
+        bindTexture(&tex_If, I);
+        bindTexture(&tex_Jf, J);
+
+        funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,
+            level, block, stream);
+    }
+
+    void sparse4(PtrStepSz<float4> I, PtrStepSz<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                 int level, dim3 block, dim3 patch, cudaStream_t stream)
+    {
+        typedef void (*func_t)(int rows, int cols, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                               int level, dim3 block, cudaStream_t stream);
+
+        static const func_t funcs[5][5] =
+        {
+            {::sparse_caller<4, 1, 1>, ::sparse_caller<4, 2, 1>, ::sparse_caller<4, 3, 1>, ::sparse_caller<4, 4, 1>, ::sparse_caller<4, 5, 1>},
+            {::sparse_caller<4, 1, 2>, ::sparse_caller<4, 2, 2>, ::sparse_caller<4, 3, 2>, ::sparse_caller<4, 4, 2>, ::sparse_caller<4, 5, 2>},
+            {::sparse_caller<4, 1, 3>, ::sparse_caller<4, 2, 3>, ::sparse_caller<4, 3, 3>, ::sparse_caller<4, 4, 3>, ::sparse_caller<4, 5, 3>},
+            {::sparse_caller<4, 1, 4>, ::sparse_caller<4, 2, 4>, ::sparse_caller<4, 3, 4>, ::sparse_caller<4, 4, 4>, ::sparse_caller<4, 5, 4>},
+            {::sparse_caller<4, 1, 5>, ::sparse_caller<4, 2, 5>, ::sparse_caller<4, 3, 5>, ::sparse_caller<4, 4, 5>, ::sparse_caller<4, 5, 5>}
+        };
+
+        bindTexture(&tex_If4, I);
+        bindTexture(&tex_Jf4, J);
+
+        funcs[patch.y - 1][patch.x - 1](I.rows, I.cols, prevPts, nextPts, status, err, ptcount,
+            level, block, stream);
+    }
+
+    void dense(PtrStepSzb I, PtrStepSzf J, PtrStepSzf u, PtrStepSzf v, PtrStepSzf prevU, PtrStepSzf prevV, PtrStepSzf err, int2 winSize, cudaStream_t stream)
+    {
+        dim3 block(16, 16);
+        dim3 grid(divUp(I.cols, block.x), divUp(I.rows, block.y));
+
+        bindTexture(&tex_Ib, I);
+        bindTexture(&tex_Jf, J);
+
+        int2 halfWin = make_int2((winSize.x - 1) / 2, (winSize.y - 1) / 2);
+        const int patchWidth  = block.x + 2 * halfWin.x;
+        const int patchHeight = block.y + 2 * halfWin.y;
+        size_t smem_size = 3 * patchWidth * patchHeight * sizeof(int);
+
+        if (err.data)
+        {
+            ::dense<true><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, err, I.rows, I.cols);
+            cudaSafeCall( cudaGetLastError() );
+        }
+        else
+        {
+            ::dense<false><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, PtrStepf(), I.rows, I.cols);
+            cudaSafeCall( cudaGetLastError() );
+        }
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
 
 #endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/pyrlk.cpp b/modules/gpu/src/pyrlk.cpp
index 47ab90415..593e37cc6 100644
--- a/modules/gpu/src/pyrlk.cpp
+++ b/modules/gpu/src/pyrlk.cpp
@@ -55,21 +55,18 @@ void cv::gpu::PyrLKOpticalFlow::releaseMemory() {}
 
 #else /* !defined (HAVE_CUDA) */
 
-namespace cv { namespace gpu { namespace device
+namespace pyrlk
 {
-    namespace pyrlk
-    {
-        void loadConstants(int2 winSize, int iters);
+    void loadConstants(int2 winSize, int iters);
 
-        void lkSparse1_gpu(PtrStepSzf I, PtrStepSzf J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-            int level, dim3 block, dim3 patch, cudaStream_t stream = 0);
-        void lkSparse4_gpu(PtrStepSz<float4> I, PtrStepSz<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
-            int level, dim3 block, dim3 patch, cudaStream_t stream = 0);
+    void sparse1(PtrStepSzf I, PtrStepSzf J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                 int level, dim3 block, dim3 patch, cudaStream_t stream = 0);
+    void sparse4(PtrStepSz<float4> I, PtrStepSz<float4> J, const float2* prevPts, float2* nextPts, uchar* status, float* err, int ptcount,
+                 int level, dim3 block, dim3 patch, cudaStream_t stream = 0);
 
-        void lkDense_gpu(PtrStepSzb I, PtrStepSzf J, PtrStepSzf u, PtrStepSzf v, PtrStepSzf prevU, PtrStepSzf prevV,
-                         PtrStepSzf err, int2 winSize, cudaStream_t stream = 0);
-    }
-}}}
+    void dense(PtrStepSzb I, PtrStepSzf J, PtrStepSzf u, PtrStepSzf v, PtrStepSzf prevU, PtrStepSzf prevV,
+               PtrStepSzf err, int2 winSize, cudaStream_t stream = 0);
+}
 
 cv::gpu::PyrLKOpticalFlow::PyrLKOpticalFlow()
 {
@@ -104,8 +101,6 @@ namespace
 
 void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& nextImg, const GpuMat& prevPts, GpuMat& nextPts, GpuMat& status, GpuMat* err)
 {
-    using namespace cv::gpu::device::pyrlk;
-
     if (prevPts.empty())
     {
         nextPts.release();
@@ -166,19 +161,19 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next
         pyrDown(nextPyr_[level - 1], nextPyr_[level]);
     }
 
-    loadConstants(make_int2(winSize.width, winSize.height), iters);
+    pyrlk::loadConstants(make_int2(winSize.width, winSize.height), iters);
 
     for (int level = maxLevel; level >= 0; level--)
     {
         if (cn == 1)
         {
-            lkSparse1_gpu(prevPyr_[level], nextPyr_[level],
+            pyrlk::sparse1(prevPyr_[level], nextPyr_[level],
                 prevPts.ptr<float2>(), nextPts.ptr<float2>(), status.ptr(), level == 0 && err ? err->ptr<float>() : 0, prevPts.cols,
                 level, block, patch);
         }
         else
         {
-            lkSparse4_gpu(prevPyr_[level], nextPyr_[level],
+            pyrlk::sparse4(prevPyr_[level], nextPyr_[level],
                 prevPts.ptr<float2>(), nextPts.ptr<float2>(), status.ptr(), level == 0 && err ? err->ptr<float>() : 0, prevPts.cols,
                 level, block, patch);
         }
@@ -187,8 +182,6 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next
 
 void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextImg, GpuMat& u, GpuMat& v, GpuMat* err)
 {
-    using namespace cv::gpu::device::pyrlk;
-
     CV_Assert(prevImg.type() == CV_8UC1);
     CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());
     CV_Assert(maxLevel >= 0);
@@ -219,7 +212,7 @@ void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextI
     vPyr_[1].setTo(Scalar::all(0));
 
     int2 winSize2i = make_int2(winSize.width, winSize.height);
-    loadConstants(winSize2i, iters);
+    pyrlk::loadConstants(winSize2i, iters);
 
     PtrStepSzf derr = err ? *err : PtrStepSzf();
 
@@ -229,7 +222,7 @@ void cv::gpu::PyrLKOpticalFlow::dense(const GpuMat& prevImg, const GpuMat& nextI
     {
         int idx2 = (idx + 1) & 1;
 
-        lkDense_gpu(prevPyr_[level], nextPyr_[level], uPyr_[idx], vPyr_[idx], uPyr_[idx2], vPyr_[idx2],
+        pyrlk::dense(prevPyr_[level], nextPyr_[level], uPyr_[idx], vPyr_[idx], uPyr_[idx2], vPyr_[idx2],
             level == 0 ? derr : PtrStepSzf(), winSize2i);
 
         if (level > 0)

From 7f97fb481cbdd3b2a432332afecb6ae7ca421d8a Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:14:48 +0400
Subject: [PATCH 086/155] FastNonLocalMeans

---
 modules/gpu/src/cuda/nlm.cu | 116 ++++++++++++++++++++++++++++--------
 1 file changed, 90 insertions(+), 26 deletions(-)

diff --git a/modules/gpu/src/cuda/nlm.cu b/modules/gpu/src/cuda/nlm.cu
index e267c733e..cd3f0b5c3 100644
--- a/modules/gpu/src/cuda/nlm.cu
+++ b/modules/gpu/src/cuda/nlm.cu
@@ -43,11 +43,11 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
-
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/vec_traits.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
-#include "opencv2/gpu/device/block.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
 
 using namespace cv::gpu;
@@ -184,6 +184,85 @@ namespace cv { namespace gpu { namespace device
 {
     namespace imgproc
     {
+
+        template <int cn> struct Unroll;
+        template <> struct Unroll<1>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&> tie(float& val1, float& val2)
+            {
+                return thrust::tie(val1, val2);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return thrust::make_tuple(op, op);
+            }
+        };
+        template <> struct Unroll<2>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&> tie(float& val1, float2& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return thrust::make_tuple(op, op, op);
+            }
+        };
+        template <> struct Unroll<3>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&> tie(float& val1, float3& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y, val2.z);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return thrust::make_tuple(op, op, op, op);
+            }
+        };
+        template <> struct Unroll<4>
+        {
+            template <int BLOCK_SIZE>
+            static __device__ __forceinline__ thrust::tuple<volatile float*, volatile float*, volatile float*, volatile float*, volatile float*> smem_tuple(float* smem)
+            {
+                return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE, smem + 4 * BLOCK_SIZE);
+            }
+
+            static __device__ __forceinline__ thrust::tuple<float&, float&, float&, float&, float&> tie(float& val1, float4& val2)
+            {
+                return thrust::tie(val1, val2.x, val2.y, val2.z, val2.w);
+            }
+
+            static __device__ __forceinline__ const thrust::tuple<plus<float>, plus<float>, plus<float>, plus<float>, plus<float> > op()
+            {
+                plus<float> op;
+                return thrust::make_tuple(op, op, op, op, op);
+            }
+        };
+
         __device__ __forceinline__ int calcDist(const uchar&  a, const uchar&  b) { return (a-b)*(a-b); }
         __device__ __forceinline__ int calcDist(const uchar2& a, const uchar2& b) { return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y); }
         __device__ __forceinline__ int calcDist(const uchar3& a, const uchar3& b) { return (a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y) + (a.z-b.z)*(a.z-b.z); }
@@ -340,30 +419,15 @@ namespace cv { namespace gpu { namespace device
                     sum = sum + weight * saturate_cast<sum_type>(src(sy + y, sx + x));
                 }
 
-                volatile __shared__ float cta_buffer[CTA_SIZE];
+                __shared__ float cta_buffer[CTA_SIZE * (VecTraits<T>::cn + 1)];
 
-                int tid = threadIdx.x;
+                reduce<CTA_SIZE>(Unroll<VecTraits<T>::cn>::template smem_tuple<CTA_SIZE>(cta_buffer),
+                                 Unroll<VecTraits<T>::cn>::tie(weights_sum, sum),
+                                 threadIdx.x,
+                                 Unroll<VecTraits<T>::cn>::op());
 
-                cta_buffer[tid] = weights_sum;
-                __syncthreads();
-                Block::reduce<CTA_SIZE>(cta_buffer, plus());
-                weights_sum = cta_buffer[0];
-
-                __syncthreads();
-
-
-                for(int n = 0; n < VecTraits<T>::cn; ++n)
-                {
-                    cta_buffer[tid] = reinterpret_cast<float*>(&sum)[n];
-                    __syncthreads();
-                    Block::reduce<CTA_SIZE>(cta_buffer, plus());
-                    reinterpret_cast<float*>(&sum)[n] = cta_buffer[0];
-
-                    __syncthreads();
-                }
-
-                if (tid == 0)
-                    dst = saturate_cast<T>(sum/weights_sum);
+                if (threadIdx.x == 0)
+                    dst = saturate_cast<T>(sum / weights_sum);
             }
 
             __device__ __forceinline__ void operator()(PtrStepSz<T>& dst) const
@@ -503,4 +567,4 @@ namespace cv { namespace gpu { namespace device
 }}}
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From 19c87d1c9d75b348bb1027afe6fc29cf7457a3c0 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:17:48 +0400
Subject: [PATCH 087/155] ORB

---
 modules/gpu/src/cuda/orb.cu | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/modules/gpu/src/cuda/orb.cu b/modules/gpu/src/cuda/orb.cu
index 91c570957..d66b3e9ec 100644
--- a/modules/gpu/src/cuda/orb.cu
+++ b/modules/gpu/src/cuda/orb.cu
@@ -50,7 +50,7 @@
 #include <thrust/sort.h>
 
 #include "opencv2/gpu/device/common.hpp"
-#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 
 namespace cv { namespace gpu { namespace device
@@ -75,9 +75,9 @@ namespace cv { namespace gpu { namespace device
 
         __global__ void HarrisResponses(const PtrStepb img, const short2* loc_, float* response, const int npoints, const int blockSize, const float harris_k)
         {
-            __shared__ int smem[8 * 32];
-
-            volatile int* srow = smem + threadIdx.y * blockDim.x;
+            __shared__ int smem0[8 * 32];
+            __shared__ int smem1[8 * 32];
+            __shared__ int smem2[8 * 32];
 
             const int ptidx = blockIdx.x * blockDim.y + threadIdx.y;
 
@@ -109,9 +109,12 @@ namespace cv { namespace gpu { namespace device
                     c += Ix * Iy;
                 }
 
-                reduce_old<32>(srow, a, threadIdx.x, plus<volatile int>());
-                reduce_old<32>(srow, b, threadIdx.x, plus<volatile int>());
-                reduce_old<32>(srow, c, threadIdx.x, plus<volatile int>());
+                int* srow0 = smem0 + threadIdx.y * blockDim.x;
+                int* srow1 = smem1 + threadIdx.y * blockDim.x;
+                int* srow2 = smem2 + threadIdx.y * blockDim.x;
+
+                plus<int> op;
+                reduce<32>(smem_tuple(srow0, srow1, srow2), thrust::tie(a, b, c), threadIdx.x, thrust::make_tuple(op, op, op));
 
                 if (threadIdx.x == 0)
                 {
@@ -151,9 +154,13 @@ namespace cv { namespace gpu { namespace device
 
         __global__ void IC_Angle(const PtrStepb image, const short2* loc_, float* angle, const int npoints, const int half_k)
         {
-            __shared__ int smem[8 * 32];
+            __shared__ int smem0[8 * 32];
+            __shared__ int smem1[8 * 32];
 
-            volatile int* srow = smem + threadIdx.y * blockDim.x;
+            int* srow0 = smem0 + threadIdx.y * blockDim.x;
+            int* srow1 = smem1 + threadIdx.y * blockDim.x;
+
+            plus<int> op;
 
             const int ptidx = blockIdx.x * blockDim.y + threadIdx.y;
 
@@ -167,7 +174,7 @@ namespace cv { namespace gpu { namespace device
                 for (int u = threadIdx.x - half_k; u <= half_k; u += blockDim.x)
                     m_10 += u * image(loc.y, loc.x + u);
 
-                reduce_old<32>(srow, m_10, threadIdx.x, plus<volatile int>());
+                reduce<32>(srow0, m_10, threadIdx.x, op);
 
                 for (int v = 1; v <= half_k; ++v)
                 {
@@ -185,8 +192,7 @@ namespace cv { namespace gpu { namespace device
                         m_sum += u * (val_plus + val_minus);
                     }
 
-                    reduce_old<32>(srow, v_sum, threadIdx.x, plus<volatile int>());
-                    reduce_old<32>(srow, m_sum, threadIdx.x, plus<volatile int>());
+                    reduce<32>(smem_tuple(srow0, srow1), thrust::tie(v_sum, m_sum), threadIdx.x, thrust::make_tuple(op, op));
 
                     m_10 += m_sum;
                     m_01 += v * v_sum;

From fbf3de43a27259959f5a6096fcc7f3bec34a5915 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:20:43 +0400
Subject: [PATCH 088/155] SURF

---
 modules/gpu/src/cuda/surf.cu         | 382 +++++++++++----------------
 modules/gpu/src/surf.cpp             |   3 +-
 modules/gpu/test/test_features2d.cpp |   2 +-
 3 files changed, 156 insertions(+), 231 deletions(-)

diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index 451fb425d..c12192555 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -47,13 +47,13 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 #include "opencv2/gpu/device/utility.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 #include "opencv2/gpu/device/filters.hpp"
-#include <float.h>
 
 namespace cv { namespace gpu { namespace device
 {
@@ -599,8 +599,9 @@ namespace cv { namespace gpu { namespace device
                     sumy += s_Y[threadIdx.x + 96];
                 }
 
-                device::reduce_old<32>(s_sumx + threadIdx.y * 32, sumx, threadIdx.x, plus<volatile float>());
-                device::reduce_old<32>(s_sumy + threadIdx.y * 32, sumy, threadIdx.x, plus<volatile float>());
+                plus<float> op;
+                device::reduce<32>(smem_tuple(s_sumx + threadIdx.y * 32, s_sumy + threadIdx.y * 32),
+                                   thrust::tie(sumx, sumy), threadIdx.x, thrust::make_tuple(op, op));
 
                 const float temp_mod = sumx * sumx + sumy * sumy;
                 if (temp_mod > best_mod)
@@ -638,7 +639,7 @@ namespace cv { namespace gpu { namespace device
                 kp_dir *= 180.0f / CV_PI_F;
 
                 kp_dir = 360.0f - kp_dir;
-                if (::fabsf(kp_dir - 360.f) < FLT_EPSILON)
+                if (::fabsf(kp_dir - 360.f) < numeric_limits<float>::epsilon())
                     kp_dir = 0.f;
 
                 featureDir[blockIdx.x] = kp_dir;
@@ -697,11 +698,6 @@ namespace cv { namespace gpu { namespace device
         {
             typedef uchar elem_type;
 
-            __device__ __forceinline__ WinReader(float centerX_, float centerY_, float win_offset_, float cos_dir_, float sin_dir_) :
-                centerX(centerX_), centerY(centerY_), win_offset(win_offset_), cos_dir(cos_dir_), sin_dir(sin_dir_)
-            {
-            }
-
             __device__ __forceinline__ uchar operator ()(int i, int j) const
             {
                 float pixel_x = centerX + (win_offset + j) * cos_dir + (win_offset + i) * sin_dir;
@@ -715,285 +711,215 @@ namespace cv { namespace gpu { namespace device
             float win_offset;
             float cos_dir;
             float sin_dir;
+            int width;
+            int height;
         };
 
-        __device__ void calc_dx_dy(float s_dx_bin[25], float s_dy_bin[25],
-            const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+        __device__ void calc_dx_dy(const float* featureX, const float* featureY, const float* featureSize, const float* featureDir,
+                                   float& dx, float& dy)
         {
-            __shared__ float s_PATCH[6][6];
+            __shared__ float s_PATCH[PATCH_SZ + 1][PATCH_SZ + 1];
 
-            const float centerX = featureX[blockIdx.x];
-            const float centerY = featureY[blockIdx.x];
-            const float size = featureSize[blockIdx.x];
-            float descriptor_dir = 360.0f - featureDir[blockIdx.x];
-            if (std::abs(descriptor_dir - 360.f) < FLT_EPSILON)
-                descriptor_dir = 0.f;
-            descriptor_dir *= (float)(CV_PI_F / 180.0f);
+            dx = dy = 0.0f;
 
-            /* The sampling intervals and wavelet sized for selecting an orientation
-             and building the keypoint descriptor are defined relative to 's' */
-            const float s = size * 1.2f / 9.0f;
+            WinReader win;
 
-            /* Extract a window of pixels around the keypoint of size 20s */
+            win.centerX = featureX[blockIdx.x];
+            win.centerY = featureY[blockIdx.x];
+
+            // The sampling intervals and wavelet sized for selecting an orientation
+            // and building the keypoint descriptor are defined relative to 's'
+            const float s = featureSize[blockIdx.x] * 1.2f / 9.0f;
+
+            // Extract a window of pixels around the keypoint of size 20s
             const int win_size = (int)((PATCH_SZ + 1) * s);
 
-            float sin_dir;
-            float cos_dir;
-            sincosf(descriptor_dir, &sin_dir, &cos_dir);
+            win.width = win.height = win_size;
 
-            /* Nearest neighbour version (faster) */
-            const float win_offset = -(float)(win_size - 1) / 2;
-
-            // Compute sampling points
-            // since grids are 2D, need to compute xBlock and yBlock indices
-            const int xBlock = (blockIdx.y & 3);  // blockIdx.y % 4
-            const int yBlock = (blockIdx.y >> 2); // floor(blockIdx.y/4)
-            const int xIndex = xBlock * 5 + threadIdx.x;
-            const int yIndex = yBlock * 5 + threadIdx.y;
-
-            const float icoo = ((float)yIndex / (PATCH_SZ + 1)) * win_size;
-            const float jcoo = ((float)xIndex / (PATCH_SZ + 1)) * win_size;
-
-            LinearFilter<WinReader> filter(WinReader(centerX, centerY, win_offset, cos_dir, sin_dir));
-
-            s_PATCH[threadIdx.y][threadIdx.x] = filter(icoo, jcoo);
-
-            __syncthreads();
-
-            if (threadIdx.x < 5 && threadIdx.y < 5)
-            {
-                const int tid = threadIdx.y * 5 + threadIdx.x;
-
-                const float dw = c_DW[yIndex * PATCH_SZ + xIndex];
-
-                const float vx = (s_PATCH[threadIdx.y    ][threadIdx.x + 1] - s_PATCH[threadIdx.y][threadIdx.x] + s_PATCH[threadIdx.y + 1][threadIdx.x + 1] - s_PATCH[threadIdx.y + 1][threadIdx.x    ]) * dw;
-                const float vy = (s_PATCH[threadIdx.y + 1][threadIdx.x    ] - s_PATCH[threadIdx.y][threadIdx.x] + s_PATCH[threadIdx.y + 1][threadIdx.x + 1] - s_PATCH[threadIdx.y    ][threadIdx.x + 1]) * dw;
-
-                s_dx_bin[tid] = vx;
-                s_dy_bin[tid] = vy;
-            }
-        }
-
-        __device__ void reduce_sum25(volatile float* sdata1, volatile float* sdata2, volatile float* sdata3, volatile float* sdata4, int tid)
-        {
-            // first step is to reduce from 25 to 16
-            if (tid < 9) // use 9 threads
-            {
-                sdata1[tid] += sdata1[tid + 16];
-                sdata2[tid] += sdata2[tid + 16];
-                sdata3[tid] += sdata3[tid + 16];
-                sdata4[tid] += sdata4[tid + 16];
-            }
-
-            // sum (reduce) from 16 to 1 (unrolled - aligned to a half-warp)
-            if (tid < 8)
-            {
-                sdata1[tid] += sdata1[tid + 8];
-                sdata1[tid] += sdata1[tid + 4];
-                sdata1[tid] += sdata1[tid + 2];
-                sdata1[tid] += sdata1[tid + 1];
-
-                sdata2[tid] += sdata2[tid + 8];
-                sdata2[tid] += sdata2[tid + 4];
-                sdata2[tid] += sdata2[tid + 2];
-                sdata2[tid] += sdata2[tid + 1];
-
-                sdata3[tid] += sdata3[tid + 8];
-                sdata3[tid] += sdata3[tid + 4];
-                sdata3[tid] += sdata3[tid + 2];
-                sdata3[tid] += sdata3[tid + 1];
-
-                sdata4[tid] += sdata4[tid + 8];
-                sdata4[tid] += sdata4[tid + 4];
-                sdata4[tid] += sdata4[tid + 2];
-                sdata4[tid] += sdata4[tid + 1];
-            }
-        }
-
-        __global__ void compute_descriptors64(PtrStepf descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
-        {
-            // 2 floats (dx,dy) for each thread (5x5 sample points in each sub-region)
-            __shared__ float sdx[25];
-            __shared__ float sdy[25];
-            __shared__ float sdxabs[25];
-            __shared__ float sdyabs[25];
-
-            calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
-            __syncthreads();
+            // Nearest neighbour version (faster)
+            win.win_offset = -(win_size - 1.0f) / 2.0f;
 
+            float descriptor_dir = 360.0f - featureDir[blockIdx.x];
+            if (::fabsf(descriptor_dir - 360.f) < numeric_limits<float>::epsilon())
+                descriptor_dir = 0.f;
+            descriptor_dir *= CV_PI_F / 180.0f;
+            sincosf(descriptor_dir, &win.sin_dir, &win.cos_dir);
 
             const int tid = threadIdx.y * blockDim.x + threadIdx.x;
 
-            if (tid < 25)
+            const int xLoadInd = tid % (PATCH_SZ + 1);
+            const int yLoadInd = tid / (PATCH_SZ + 1);
+
+            if (yLoadInd < (PATCH_SZ + 1))
             {
-                sdxabs[tid] = ::fabs(sdx[tid]); // |dx| array
-                sdyabs[tid] = ::fabs(sdy[tid]); // |dy| array
-                __syncthreads();
-
-                reduce_sum25(sdx, sdy, sdxabs, sdyabs, tid);
-                __syncthreads();
-
-                float* descriptors_block = descriptors.ptr(blockIdx.x) + (blockIdx.y << 2);
-
-                // write dx, dy, |dx|, |dy|
-                if (tid == 0)
+                if (s > 1)
                 {
-                    descriptors_block[0] = sdx[0];
-                    descriptors_block[1] = sdy[0];
-                    descriptors_block[2] = sdxabs[0];
-                    descriptors_block[3] = sdyabs[0];
+                    AreaFilter<WinReader> filter(win, s, s);
+                    s_PATCH[yLoadInd][xLoadInd] = filter(yLoadInd, xLoadInd);
                 }
+                else
+                {
+                    LinearFilter<WinReader> filter(win);
+                    s_PATCH[yLoadInd][xLoadInd] = filter(yLoadInd * s, xLoadInd * s);
+                }
+            }
+
+            __syncthreads();
+
+            const int xPatchInd = threadIdx.x % 5;
+            const int yPatchInd = threadIdx.x / 5;
+
+            if (yPatchInd < 5)
+            {
+                const int xBlockInd = threadIdx.y % 4;
+                const int yBlockInd = threadIdx.y / 4;
+
+                const int xInd = xBlockInd * 5 + xPatchInd;
+                const int yInd = yBlockInd * 5 + yPatchInd;
+
+                const float dw = c_DW[yInd * PATCH_SZ + xInd];
+
+                dx = (s_PATCH[yInd    ][xInd + 1] - s_PATCH[yInd][xInd] + s_PATCH[yInd + 1][xInd + 1] - s_PATCH[yInd + 1][xInd    ]) * dw;
+                dy = (s_PATCH[yInd + 1][xInd    ] - s_PATCH[yInd][xInd] + s_PATCH[yInd + 1][xInd + 1] - s_PATCH[yInd    ][xInd + 1]) * dw;
             }
         }
 
-        __global__ void compute_descriptors128(PtrStepf descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+        __global__ void compute_descriptors_64(PtrStep<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
         {
-            // 2 floats (dx,dy) for each thread (5x5 sample points in each sub-region)
-            __shared__ float sdx[25];
-            __shared__ float sdy[25];
+            __shared__ float smem[32 * 16];
 
-            // sum (reduce) 5x5 area response
-            __shared__ float sd1[25];
-            __shared__ float sd2[25];
-            __shared__ float sdabs1[25];
-            __shared__ float sdabs2[25];
+            float* sRow = smem + threadIdx.y * 32;
 
-            calc_dx_dy(sdx, sdy, featureX, featureY, featureSize, featureDir);
-            __syncthreads();
+            float dx, dy;
+            calc_dx_dy(featureX, featureY, featureSize, featureDir, dx, dy);
 
-            const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+            float dxabs = ::fabsf(dx);
+            float dyabs = ::fabsf(dy);
 
-            if (tid < 25)
+            plus<float> op;
+
+            reduce<32>(sRow, dx, threadIdx.x, op);
+            reduce<32>(sRow, dy, threadIdx.x, op);
+            reduce<32>(sRow, dxabs, threadIdx.x, op);
+            reduce<32>(sRow, dyabs, threadIdx.x, op);
+
+            float4* descriptors_block = descriptors.ptr(blockIdx.x) + threadIdx.y;
+
+            // write dx, dy, |dx|, |dy|
+            if (threadIdx.x == 0)
+                *descriptors_block = make_float4(dx, dy, dxabs, dyabs);
+        }
+
+        __global__ void compute_descriptors_128(PtrStep<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir)
+        {
+            __shared__ float smem[32 * 16];
+
+            float* sRow = smem + threadIdx.y * 32;
+
+            float dx, dy;
+            calc_dx_dy(featureX, featureY, featureSize, featureDir, dx, dy);
+
+            float4* descriptors_block = descriptors.ptr(blockIdx.x) + threadIdx.y * 2;
+
+            plus<float> op;
+
+            float d1 = 0.0f;
+            float d2 = 0.0f;
+            float abs1 = 0.0f;
+            float abs2 = 0.0f;
+
+            if (dy >= 0)
             {
-                if (sdy[tid] >= 0)
-                {
-                    sd1[tid] = sdx[tid];
-                    sdabs1[tid] = ::fabs(sdx[tid]);
-                    sd2[tid] = 0;
-                    sdabs2[tid] = 0;
-                }
-                else
-                {
-                    sd1[tid] = 0;
-                    sdabs1[tid] = 0;
-                    sd2[tid] = sdx[tid];
-                    sdabs2[tid] = ::fabs(sdx[tid]);
-                }
-                __syncthreads();
-
-                reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
-                __syncthreads();
-
-                float* descriptors_block = descriptors.ptr(blockIdx.x) + (blockIdx.y << 3);
-
-                // write dx (dy >= 0), |dx| (dy >= 0), dx (dy < 0), |dx| (dy < 0)
-                if (tid == 0)
-                {
-                    descriptors_block[0] = sd1[0];
-                    descriptors_block[1] = sdabs1[0];
-                    descriptors_block[2] = sd2[0];
-                    descriptors_block[3] = sdabs2[0];
-                }
-                __syncthreads();
-
-                if (sdx[tid] >= 0)
-                {
-                    sd1[tid] = sdy[tid];
-                    sdabs1[tid] = ::fabs(sdy[tid]);
-                    sd2[tid] = 0;
-                    sdabs2[tid] = 0;
-                }
-                else
-                {
-                    sd1[tid] = 0;
-                    sdabs1[tid] = 0;
-                    sd2[tid] = sdy[tid];
-                    sdabs2[tid] = ::fabs(sdy[tid]);
-                }
-                __syncthreads();
-
-                reduce_sum25(sd1, sd2, sdabs1, sdabs2, tid);
-                __syncthreads();
-
-                // write dy (dx >= 0), |dy| (dx >= 0), dy (dx < 0), |dy| (dx < 0)
-                if (tid == 0)
-                {
-                    descriptors_block[4] = sd1[0];
-                    descriptors_block[5] = sdabs1[0];
-                    descriptors_block[6] = sd2[0];
-                    descriptors_block[7] = sdabs2[0];
-                }
+                d1 = dx;
+                abs1 = ::fabsf(dx);
             }
+            else
+            {
+                d2 = dx;
+                abs2 = ::fabsf(dx);
+            }
+
+            reduce<32>(sRow, d1, threadIdx.x, op);
+            reduce<32>(sRow, d2, threadIdx.x, op);
+            reduce<32>(sRow, abs1, threadIdx.x, op);
+            reduce<32>(sRow, abs2, threadIdx.x, op);
+
+            // write dx (dy >= 0), |dx| (dy >= 0), dx (dy < 0), |dx| (dy < 0)
+            if (threadIdx.x == 0)
+                descriptors_block[0] = make_float4(d1, abs1, d2, abs2);
+
+            if (dx >= 0)
+            {
+                d1 = dy;
+                abs1 = ::fabsf(dy);
+                d2 = 0.0f;
+                abs2 = 0.0f;
+            }
+            else
+            {
+                d1 = 0.0f;
+                abs1 = 0.0f;
+                d2 = dy;
+                abs2 = ::fabsf(dy);
+            }
+
+            reduce<32>(sRow, d1, threadIdx.x, op);
+            reduce<32>(sRow, d2, threadIdx.x, op);
+            reduce<32>(sRow, abs1, threadIdx.x, op);
+            reduce<32>(sRow, abs2, threadIdx.x, op);
+
+            // write dy (dx >= 0), |dy| (dx >= 0), dy (dx < 0), |dy| (dx < 0)
+            if (threadIdx.x == 0)
+                descriptors_block[1] = make_float4(d1, abs1, d2, abs2);
         }
 
         template <int BLOCK_DIM_X> __global__ void normalize_descriptors(PtrStepf descriptors)
         {
+            __shared__ float smem[BLOCK_DIM_X];
+            __shared__ float s_len;
+
             // no need for thread ID
             float* descriptor_base = descriptors.ptr(blockIdx.x);
 
             // read in the unnormalized descriptor values (squared)
-            __shared__ float sqDesc[BLOCK_DIM_X];
-            const float lookup = descriptor_base[threadIdx.x];
-            sqDesc[threadIdx.x] = lookup * lookup;
-            __syncthreads();
+            const float val = descriptor_base[threadIdx.x];
 
-            if (BLOCK_DIM_X >= 128)
-            {
-                if (threadIdx.x < 64)
-                    sqDesc[threadIdx.x] += sqDesc[threadIdx.x + 64];
-                __syncthreads();
-            }
+            float len = val * val;
+            reduce<BLOCK_DIM_X>(smem, len, threadIdx.x, plus<float>());
 
-            // reduction to get total
-            if (threadIdx.x < 32)
-            {
-                volatile float* smem = sqDesc;
-
-                smem[threadIdx.x] += smem[threadIdx.x + 32];
-                smem[threadIdx.x] += smem[threadIdx.x + 16];
-                smem[threadIdx.x] += smem[threadIdx.x + 8];
-                smem[threadIdx.x] += smem[threadIdx.x + 4];
-                smem[threadIdx.x] += smem[threadIdx.x + 2];
-                smem[threadIdx.x] += smem[threadIdx.x + 1];
-            }
-
-            // compute length (square root)
-            __shared__ float len;
             if (threadIdx.x == 0)
-            {
-                len = sqrtf(sqDesc[0]);
-            }
+                s_len = ::sqrtf(len);
+
             __syncthreads();
 
             // normalize and store in output
-            descriptor_base[threadIdx.x] = lookup / len;
+            descriptor_base[threadIdx.x] = val / s_len;
         }
 
-        void compute_descriptors_gpu(const PtrStepSzf& descriptors,
-            const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures)
+        void compute_descriptors_gpu(PtrStepSz<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures)
         {
             // compute unnormalized descriptors, then normalize them - odd indexing since grid must be 2D
 
             if (descriptors.cols == 64)
             {
-                compute_descriptors64<<<dim3(nFeatures, 16, 1), dim3(6, 6, 1)>>>(descriptors, featureX, featureY, featureSize, featureDir);
+                compute_descriptors_64<<<nFeatures, dim3(32, 16)>>>(descriptors, featureX, featureY, featureSize, featureDir);
                 cudaSafeCall( cudaGetLastError() );
 
                 cudaSafeCall( cudaDeviceSynchronize() );
 
-                normalize_descriptors<64><<<dim3(nFeatures, 1, 1), dim3(64, 1, 1)>>>(descriptors);
+                normalize_descriptors<64><<<nFeatures, 64>>>((PtrStepSzf) descriptors);
                 cudaSafeCall( cudaGetLastError() );
 
                 cudaSafeCall( cudaDeviceSynchronize() );
             }
             else
             {
-                compute_descriptors128<<<dim3(nFeatures, 16, 1), dim3(6, 6, 1)>>>(descriptors, featureX, featureY, featureSize, featureDir);
+                compute_descriptors_128<<<nFeatures, dim3(32, 16)>>>(descriptors, featureX, featureY, featureSize, featureDir);
                 cudaSafeCall( cudaGetLastError() );
 
                 cudaSafeCall( cudaDeviceSynchronize() );
 
-                normalize_descriptors<128><<<dim3(nFeatures, 1, 1), dim3(128, 1, 1)>>>(descriptors);
+                normalize_descriptors<128><<<nFeatures, 128>>>((PtrStepSzf) descriptors);
                 cudaSafeCall( cudaGetLastError() );
 
                 cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/surf.cpp b/modules/gpu/src/surf.cpp
index 72bb9c15e..4d1e74d9a 100644
--- a/modules/gpu/src/surf.cpp
+++ b/modules/gpu/src/surf.cpp
@@ -86,8 +86,7 @@ namespace cv { namespace gpu { namespace device
 
         void icvCalcOrientation_gpu(const float* featureX, const float* featureY, const float* featureSize, float* featureDir, int nFeatures);
 
-        void compute_descriptors_gpu(const PtrStepSzf& descriptors,
-            const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
+        void compute_descriptors_gpu(PtrStepSz<float4> descriptors, const float* featureX, const float* featureY, const float* featureSize, const float* featureDir, int nFeatures);
     }
 }}}
 
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index 4fff37f1a..c76fe9166 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -328,7 +328,7 @@ TEST_P(SURF, Descriptor)
         int matchedCount = getMatchedPointsCount(keypoints, keypoints, matches);
         double matchedRatio = static_cast<double>(matchedCount) / keypoints.size();
 
-        EXPECT_GT(matchedRatio, 0.35);
+        EXPECT_GT(matchedRatio, 0.6);
     }
 }
 

From e8f9762ef373be508692d2d692d5c5a97ad533f9 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 13:34:25 +0400
Subject: [PATCH 089/155] matrix reduction

---
 modules/gpu/src/cuda/matrix_reductions.cu | 3220 ++++++++-------------
 modules/gpu/src/matrix_reductions.cpp     |  756 ++---
 modules/gpu/test/test_core.cpp            |   14 +-
 3 files changed, 1521 insertions(+), 2469 deletions(-)

diff --git a/modules/gpu/src/cuda/matrix_reductions.cu b/modules/gpu/src/cuda/matrix_reductions.cu
index 5cda3dab3..7a0e8d2fe 100644
--- a/modules/gpu/src/cuda/matrix_reductions.cu
+++ b/modules/gpu/src/cuda/matrix_reductions.cu
@@ -42,2062 +42,1268 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
+#include "opencv2/gpu/device/vec_traits.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/utility.hpp"
+#include "opencv2/gpu/device/type_traits.hpp"
 
-namespace cv { namespace gpu { namespace device
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
 {
-    namespace matrix_reductions
+    template <int cn> struct Unroll;
+    template <> struct Unroll<1>
     {
-        // Performs reduction in shared memory
-        template <int size, typename T>
-        __device__ void sumInSmem(volatile T* data, const uint tid)
+        template <int BLOCK_SIZE, typename R>
+        static __device__ __forceinline__ volatile R* smem_tuple(R* smem)
         {
-            T sum = data[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)
-            {
-                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];
-            }
+            return smem;
         }
 
-        struct Mask8U
+        template <typename R>
+        static __device__ __forceinline__ R& tie(R& val)
         {
-            explicit Mask8U(PtrStepb mask_): mask(mask_) {}
+            return val;
+        }
 
-            __device__ __forceinline__ bool operator()(int y, int x) const
-            {
-                return mask.ptr(y)[x];
-            }
-
-            PtrStepb mask;
-        };
-
-        struct MaskTrue
+        template <class Op>
+        static __device__ __forceinline__ const Op& op(const Op& op)
         {
-            __device__ __forceinline__ bool operator()(int y, int x) const
-            {
-                return true;
-            }
-            __device__ __forceinline__ MaskTrue(){}
-            __device__ __forceinline__ MaskTrue(const MaskTrue& mask_){}
-        };
-
-        //////////////////////////////////////////////////////////////////////////////
-        // 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
+            return op;
+        }
+    };
+    template <> struct Unroll<2>
+    {
+        template <int BLOCK_SIZE, typename R>
+        static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*> smem_tuple(R* smem)
         {
-            __constant__ int ctwidth;
-            __constant__ int ctheight;
+            return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE);
+        }
 
-            // Global counter of blocks finished its work
-            __device__ uint blocks_finished = 0;
-
-
-            // Estimates good thread configuration
-            //  - threads variable satisfies to threads.x * threads.y == 256
-            void estimateThreadCfg(int cols, int rows, dim3& threads, dim3& grid)
-            {
-                threads = dim3(32, 8);
-                grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-                grid.x = std::min(grid.x, threads.x);
-                grid.y = std::min(grid.y, threads.y);
-            }
-
-
-            // Returns required buffer sizes
-            void getBufSizeRequired(int cols, int rows, int elem_size, int& bufcols, int& bufrows)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(cols, rows, threads, grid);
-                bufcols = grid.x * grid.y * elem_size;
-                bufrows = 2;
-            }
-
-
-            // Estimates device constants which are used in the kernels using specified thread configuration
-            void setKernelConsts(int cols, int rows, const dim3& threads, const dim3& grid)
-            {
-                int twidth = divUp(divUp(cols, grid.x), threads.x);
-                int theight = divUp(divUp(rows, grid.y), threads.y);
-                cudaSafeCall(cudaMemcpyToSymbol(ctwidth, &twidth, sizeof(ctwidth)));
-                cudaSafeCall(cudaMemcpyToSymbol(ctheight, &theight, sizeof(ctheight)));
-            }
-
-
-            // Does min and max in shared memory
-            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]);
-            }
-
-
-            template <int size, typename T>
-            __device__ void findMinMaxInSmem(volatile T* minval, volatile T* maxval, const uint tid)
-            {
-                if (size >= 512) { if (tid < 256) { merge(tid, 256, minval, maxval); } __syncthreads(); }
-                if (size >= 256) { if (tid < 128) { merge(tid, 128, minval, maxval); }  __syncthreads(); }
-                if (size >= 128) { if (tid < 64) { merge(tid, 64, minval, maxval); } __syncthreads(); }
-
-                if (tid < 32)
-                {
-                    if (size >= 64) merge(tid, 32, minval, maxval);
-                    if (size >= 32) merge(tid, 16, minval, maxval);
-                    if (size >= 16) merge(tid, 8, minval, maxval);
-                    if (size >= 8) merge(tid, 4, minval, maxval);
-                    if (size >= 4) merge(tid, 2, minval, maxval);
-                    if (size >= 2) merge(tid, 1, minval, maxval);
-                }
-            }
-
-
-            template <int nthreads, typename T, typename Mask>
-            __global__ void minMaxKernel(const PtrStepSzb src, Mask mask, T* minval, T* maxval)
-            {
-                typedef typename MinMaxTypeTraits<T>::best_type best_type;
-                __shared__ best_type sminval[nthreads];
-                __shared__ best_type smaxval[nthreads];
-
-                uint x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                uint y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                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();
-                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);
-                    for (uint x = x0; x < x_end; x += blockDim.x)
-                    {
-                        T val = src_row[x];
-                        if (mask(y, x))
-                        {
-                            mymin = ::min(mymin, val);
-                            mymax = ::max(mymax, val);
-                        }
-                    }
-                }
-
-                sminval[tid] = mymin;
-                smaxval[tid] = mymax;
-                __syncthreads();
-
-                findMinMaxInSmem<nthreads, best_type>(sminval, smaxval, tid);
-
-                if (tid == 0)
-                {
-                    minval[blockIdx.y * gridDim.x + blockIdx.x] = (T)sminval[0];
-                    maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
-                }
-
-            #if defined (__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    minval[blockIdx.y * gridDim.x + blockIdx.x] = (T)sminval[0];
-                    maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = ticket == gridDim.x * gridDim.y - 1;
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
-
-                    sminval[tid] = minval[idx];
-                    smaxval[tid] = maxval[idx];
-                    __syncthreads();
-
-                    findMinMaxInSmem<nthreads, best_type>(sminval, smaxval, tid);
-
-                    if (tid == 0)
-                    {
-                        minval[0] = (T)sminval[0];
-                        maxval[0] = (T)smaxval[0];
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0)
-                {
-                    minval[blockIdx.y * gridDim.x + blockIdx.x] = (T)sminval[0];
-                    maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
-                }
-            #endif
-            }
-
-
-            template <typename T>
-            void minMaxMaskCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)buf.ptr(0);
-                T* maxval_buf = (T*)buf.ptr(1);
-
-                minMaxKernel<256, T, Mask8U><<<grid, threads>>>(src, Mask8U(mask), minval_buf, maxval_buf);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                *minval = minval_;
-                *maxval = maxval_;
-            }
-
-            template void minMaxMaskCaller<uchar>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<char>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<ushort>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<short>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<int>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<float>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskCaller<double>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-
-
-            template <typename T>
-            void minMaxCaller(const PtrStepSzb src, double* minval, double* maxval, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)buf.ptr(0);
-                T* maxval_buf = (T*)buf.ptr(1);
-
-                minMaxKernel<256, T, MaskTrue><<<grid, threads>>>(src, MaskTrue(), minval_buf, maxval_buf);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                *minval = minval_;
-                *maxval = maxval_;
-            }
-
-            template void minMaxCaller<uchar>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxCaller<char>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxCaller<ushort>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxCaller<short>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxCaller<int>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxCaller<float>(const PtrStepSzb, double*,double*, PtrStepb);
-            template void minMaxCaller<double>(const PtrStepSzb, double*, double*, PtrStepb);
-
-
-            template <int nthreads, typename T>
-            __global__ void minMaxPass2Kernel(T* minval, T* maxval, int size)
-            {
-                typedef typename MinMaxTypeTraits<T>::best_type best_type;
-                __shared__ best_type sminval[nthreads];
-                __shared__ best_type smaxval[nthreads];
-
-                uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-                uint idx = ::min(tid, size - 1);
-
-                sminval[tid] = minval[idx];
-                smaxval[tid] = maxval[idx];
-                __syncthreads();
-
-                findMinMaxInSmem<nthreads, best_type>(sminval, smaxval, tid);
-
-                if (tid == 0)
-                {
-                    minval[0] = (T)sminval[0];
-                    maxval[0] = (T)smaxval[0];
-                }
-            }
-
-
-            template <typename T>
-            void minMaxMaskMultipassCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)buf.ptr(0);
-                T* maxval_buf = (T*)buf.ptr(1);
-
-                minMaxKernel<256, T, Mask8U><<<grid, threads>>>(src, Mask8U(mask), minval_buf, maxval_buf);
-                cudaSafeCall( cudaGetLastError() );
-                minMaxPass2Kernel<256, T><<<1, 256>>>(minval_buf, maxval_buf, grid.x * grid.y);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall(cudaDeviceSynchronize());
-
-                T minval_, maxval_;
-                cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                *minval = minval_;
-                *maxval = maxval_;
-            }
-
-            template void minMaxMaskMultipassCaller<uchar>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskMultipassCaller<char>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskMultipassCaller<ushort>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskMultipassCaller<short>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskMultipassCaller<int>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-            template void minMaxMaskMultipassCaller<float>(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-
-
-            template <typename T>
-            void minMaxMultipassCaller(const PtrStepSzb src, double* minval, double* maxval, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)buf.ptr(0);
-                T* maxval_buf = (T*)buf.ptr(1);
-
-                minMaxKernel<256, T, MaskTrue><<<grid, threads>>>(src, MaskTrue(), minval_buf, maxval_buf);
-                cudaSafeCall( cudaGetLastError() );
-                minMaxPass2Kernel<256, T><<<1, 256>>>(minval_buf, maxval_buf, grid.x * grid.y);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                *minval = minval_;
-                *maxval = maxval_;
-            }
-
-            template void minMaxMultipassCaller<uchar>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxMultipassCaller<char>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxMultipassCaller<ushort>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxMultipassCaller<short>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxMultipassCaller<int>(const PtrStepSzb, double*, double*, PtrStepb);
-            template void minMaxMultipassCaller<float>(const PtrStepSzb, double*, double*, PtrStepb);
-        } // namespace minmax
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // minMaxLoc
-
-        namespace minmaxloc
+        template <typename R>
+        static __device__ __forceinline__ thrust::tuple<typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&> tie(R& val)
         {
-            __constant__ int ctwidth;
-            __constant__ int ctheight;
+            return thrust::tie(val.x, val.y);
+        }
 
-            // Global counter of blocks finished its work
-            __device__ uint blocks_finished = 0;
-
-
-            // Estimates good thread configuration
-            //  - threads variable satisfies to threads.x * threads.y == 256
-            void estimateThreadCfg(int cols, int rows, dim3& threads, dim3& grid)
-            {
-                threads = dim3(32, 8);
-                grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-                grid.x = std::min(grid.x, threads.x);
-                grid.y = std::min(grid.y, threads.y);
-            }
-
-
-            // Returns required buffer sizes
-            void getBufSizeRequired(int cols, int rows, int elem_size, int& b1cols,
-                                    int& b1rows, int& b2cols, int& b2rows)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(cols, rows, threads, grid);
-                b1cols = grid.x * grid.y * elem_size; // For values
-                b1rows = 2;
-                b2cols = grid.x * grid.y * sizeof(int); // For locations
-                b2rows = 2;
-            }
-
-
-            // Estimates device constants which are used in the kernels using specified thread configuration
-            void setKernelConsts(int cols, int rows, const dim3& threads, const dim3& grid)
-            {
-                int twidth = divUp(divUp(cols, grid.x), threads.x);
-                int theight = divUp(divUp(rows, grid.y), threads.y);
-                cudaSafeCall(cudaMemcpyToSymbol(ctwidth, &twidth, sizeof(ctwidth)));
-                cudaSafeCall(cudaMemcpyToSymbol(ctheight, &theight, sizeof(ctheight)));
-            }
-
-
-            template <typename T>
-            __device__ void merge(uint tid, uint offset, volatile T* minval, volatile T* maxval,
-                                  volatile uint* minloc, volatile uint* maxloc)
-            {
-                T val = minval[tid + offset];
-                if (val < minval[tid])
-                {
-                    minval[tid] = val;
-                    minloc[tid] = minloc[tid + offset];
-                }
-                val = maxval[tid + offset];
-                if (val > maxval[tid])
-                {
-                    maxval[tid] = val;
-                    maxloc[tid] = maxloc[tid + offset];
-                }
-            }
-
-
-            template <int size, typename T>
-            __device__ void findMinMaxLocInSmem(volatile T* minval, volatile T* maxval, volatile uint* minloc,
-                                                volatile uint* maxloc, const uint tid)
-            {
-                if (size >= 512) { if (tid < 256) { merge(tid, 256, minval, maxval, minloc, maxloc); } __syncthreads(); }
-                if (size >= 256) { if (tid < 128) { merge(tid, 128, minval, maxval, minloc, maxloc); }  __syncthreads(); }
-                if (size >= 128) { if (tid < 64) { merge(tid, 64, minval, maxval, minloc, maxloc); } __syncthreads(); }
-
-                if (tid < 32)
-                {
-                    if (size >= 64) merge(tid, 32, minval, maxval, minloc, maxloc);
-                    if (size >= 32) merge(tid, 16, minval, maxval, minloc, maxloc);
-                    if (size >= 16) merge(tid, 8, minval, maxval, minloc, maxloc);
-                    if (size >= 8) merge(tid, 4, minval, maxval, minloc, maxloc);
-                    if (size >= 4) merge(tid, 2, minval, maxval, minloc, maxloc);
-                    if (size >= 2) merge(tid, 1, minval, maxval, minloc, maxloc);
-                }
-            }
-
-
-            template <int nthreads, typename T, typename Mask>
-            __global__ void minMaxLocKernel(const PtrStepSzb src, Mask mask, T* minval, T* maxval,
-                                            uint* minloc, uint* maxloc)
-            {
-                typedef typename MinMaxTypeTraits<T>::best_type best_type;
-                __shared__ best_type sminval[nthreads];
-                __shared__ best_type smaxval[nthreads];
-                __shared__ uint sminloc[nthreads];
-                __shared__ uint smaxloc[nthreads];
-
-                uint x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                uint y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                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();
-                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);
-
-                for (uint y = y0; y < y_end; y += blockDim.y)
-                {
-                    const T* ptr = (const T*)src.ptr(y);
-                    for (uint x = x0; x < x_end; x += blockDim.x)
-                    {
-                        if (mask(y, x))
-                        {
-                            T val = ptr[x];
-                            if (val <= mymin) { mymin = val; myminloc = y * src.cols + x; }
-                            if (val >= mymax) { mymax = val; mymaxloc = y * src.cols + x; }
-                        }
-                    }
-                }
-
-                sminval[tid] = mymin;
-                smaxval[tid] = mymax;
-                sminloc[tid] = myminloc;
-                smaxloc[tid] = mymaxloc;
-                __syncthreads();
-
-                findMinMaxLocInSmem<nthreads, best_type>(sminval, smaxval, sminloc, smaxloc, tid);
-
-            #if defined (__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    minval[blockIdx.y * gridDim.x + blockIdx.x] = (T)sminval[0];
-                    maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
-                    minloc[blockIdx.y * gridDim.x + blockIdx.x] = sminloc[0];
-                    maxloc[blockIdx.y * gridDim.x + blockIdx.x] = smaxloc[0];
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = ticket == gridDim.x * gridDim.y - 1;
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    uint idx = ::min(tid, gridDim.x * gridDim.y - 1);
-
-                    sminval[tid] = minval[idx];
-                    smaxval[tid] = maxval[idx];
-                    sminloc[tid] = minloc[idx];
-                    smaxloc[tid] = maxloc[idx];
-                    __syncthreads();
-
-                    findMinMaxLocInSmem<nthreads, best_type>(sminval, smaxval, sminloc, smaxloc, tid);
-
-                    if (tid == 0)
-                    {
-                        minval[0] = (T)sminval[0];
-                        maxval[0] = (T)smaxval[0];
-                        minloc[0] = sminloc[0];
-                        maxloc[0] = smaxloc[0];
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0)
-                {
-                    minval[blockIdx.y * gridDim.x + blockIdx.x] = (T)sminval[0];
-                    maxval[blockIdx.y * gridDim.x + blockIdx.x] = (T)smaxval[0];
-                    minloc[blockIdx.y * gridDim.x + blockIdx.x] = sminloc[0];
-                    maxloc[blockIdx.y * gridDim.x + blockIdx.x] = smaxloc[0];
-                }
-            #endif
-            }
-
-
-            template <typename T>
-            void minMaxLocMaskCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval,
-                                     int minloc[2], int maxloc[2], PtrStepb valbuf, PtrStepb locbuf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)valbuf.ptr(0);
-                T* maxval_buf = (T*)valbuf.ptr(1);
-                uint* minloc_buf = (uint*)locbuf.ptr(0);
-                uint* maxloc_buf = (uint*)locbuf.ptr(1);
-
-                minMaxLocKernel<256, T, Mask8U><<<grid, threads>>>(src, Mask8U(mask), minval_buf, maxval_buf,
-                                                                   minloc_buf, maxloc_buf);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
-                *minval = minval_;
-                *maxval = maxval_;
-
-                uint minloc_, maxloc_;
-                cudaSafeCall( cudaMemcpy(&minloc_, minloc_buf, sizeof(int), cudaMemcpyDeviceToHost) );
-                cudaSafeCall( cudaMemcpy(&maxloc_, maxloc_buf, sizeof(int), cudaMemcpyDeviceToHost) );
-                minloc[1] = minloc_ / src.cols; minloc[0] = minloc_ - minloc[1] * src.cols;
-                maxloc[1] = maxloc_ / src.cols; maxloc[0] = maxloc_ - maxloc[1] * src.cols;
-            }
-
-            template void minMaxLocMaskCaller<uchar>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<char>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<ushort>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<short>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<int>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<float>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskCaller<double>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-
-            template <typename T>
-            void minMaxLocCaller(const PtrStepSzb src, double* minval, double* maxval,
-                                 int minloc[2], int maxloc[2], PtrStepb valbuf, PtrStepb locbuf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)valbuf.ptr(0);
-                T* maxval_buf = (T*)valbuf.ptr(1);
-                uint* minloc_buf = (uint*)locbuf.ptr(0);
-                uint* maxloc_buf = (uint*)locbuf.ptr(1);
-
-                minMaxLocKernel<256, T, MaskTrue><<<grid, threads>>>(src, MaskTrue(), minval_buf, maxval_buf,
-                                                                     minloc_buf, maxloc_buf);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall(cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                *minval = minval_;
-                *maxval = maxval_;
-
-                uint minloc_, maxloc_;
-                cudaSafeCall(cudaMemcpy(&minloc_, minloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxloc_, maxloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                minloc[1] = minloc_ / src.cols; minloc[0] = minloc_ - minloc[1] * src.cols;
-                maxloc[1] = maxloc_ / src.cols; maxloc[0] = maxloc_ - maxloc[1] * src.cols;
-            }
-
-            template void minMaxLocCaller<uchar>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<char>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<ushort>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<short>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<int>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<float>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocCaller<double>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-
-            // This kernel will be used only when compute capability is 1.0
-            template <int nthreads, typename T>
-            __global__ void minMaxLocPass2Kernel(T* minval, T* maxval, uint* minloc, uint* maxloc, int size)
-            {
-                typedef typename MinMaxTypeTraits<T>::best_type best_type;
-                __shared__ best_type sminval[nthreads];
-                __shared__ best_type smaxval[nthreads];
-                __shared__ uint sminloc[nthreads];
-                __shared__ uint smaxloc[nthreads];
-
-                uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-                uint idx = ::min(tid, size - 1);
-
-                sminval[tid] = minval[idx];
-                smaxval[tid] = maxval[idx];
-                sminloc[tid] = minloc[idx];
-                smaxloc[tid] = maxloc[idx];
-                __syncthreads();
-
-                findMinMaxLocInSmem<nthreads, best_type>(sminval, smaxval, sminloc, smaxloc, tid);
-
-                if (tid == 0)
-                {
-                    minval[0] = (T)sminval[0];
-                    maxval[0] = (T)smaxval[0];
-                    minloc[0] = sminloc[0];
-                    maxloc[0] = smaxloc[0];
-                }
-            }
-
-
-            template <typename T>
-            void minMaxLocMaskMultipassCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval,
-                                              int minloc[2], int maxloc[2], PtrStepb valbuf, PtrStepb locbuf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)valbuf.ptr(0);
-                T* maxval_buf = (T*)valbuf.ptr(1);
-                uint* minloc_buf = (uint*)locbuf.ptr(0);
-                uint* maxloc_buf = (uint*)locbuf.ptr(1);
-
-                minMaxLocKernel<256, T, Mask8U><<<grid, threads>>>(src, Mask8U(mask), minval_buf, maxval_buf,
-                                                                   minloc_buf, maxloc_buf);
-                cudaSafeCall( cudaGetLastError() );
-                minMaxLocPass2Kernel<256, T><<<1, 256>>>(minval_buf, maxval_buf, minloc_buf, maxloc_buf, grid.x * grid.y);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall(cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                *minval = minval_;
-                *maxval = maxval_;
-
-                uint minloc_, maxloc_;
-                cudaSafeCall(cudaMemcpy(&minloc_, minloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxloc_, maxloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                minloc[1] = minloc_ / src.cols; minloc[0] = minloc_ - minloc[1] * src.cols;
-                maxloc[1] = maxloc_ / src.cols; maxloc[0] = maxloc_ - maxloc[1] * src.cols;
-            }
-
-            template void minMaxLocMaskMultipassCaller<uchar>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskMultipassCaller<char>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskMultipassCaller<ushort>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskMultipassCaller<short>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskMultipassCaller<int>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMaskMultipassCaller<float>(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-
-            template <typename T>
-            void minMaxLocMultipassCaller(const PtrStepSzb src, double* minval, double* maxval,
-                                          int minloc[2], int maxloc[2], PtrStepb valbuf, PtrStepb locbuf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                T* minval_buf = (T*)valbuf.ptr(0);
-                T* maxval_buf = (T*)valbuf.ptr(1);
-                uint* minloc_buf = (uint*)locbuf.ptr(0);
-                uint* maxloc_buf = (uint*)locbuf.ptr(1);
-
-                minMaxLocKernel<256, T, MaskTrue><<<grid, threads>>>(src, MaskTrue(), minval_buf, maxval_buf,
-                                                                     minloc_buf, maxloc_buf);
-                cudaSafeCall( cudaGetLastError() );
-                minMaxLocPass2Kernel<256, T><<<1, 256>>>(minval_buf, maxval_buf, minloc_buf, maxloc_buf, grid.x * grid.y);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                T minval_, maxval_;
-                cudaSafeCall(cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost));
-                *minval = minval_;
-                *maxval = maxval_;
-
-                uint minloc_, maxloc_;
-                cudaSafeCall(cudaMemcpy(&minloc_, minloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                cudaSafeCall(cudaMemcpy(&maxloc_, maxloc_buf, sizeof(int), cudaMemcpyDeviceToHost));
-                minloc[1] = minloc_ / src.cols; minloc[0] = minloc_ - minloc[1] * src.cols;
-                maxloc[1] = maxloc_ / src.cols; maxloc[0] = maxloc_ - maxloc[1] * src.cols;
-            }
-
-            template void minMaxLocMultipassCaller<uchar>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMultipassCaller<char>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMultipassCaller<ushort>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMultipassCaller<short>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMultipassCaller<int>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-            template void minMaxLocMultipassCaller<float>(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-        } // namespace minmaxloc
-
-        //////////////////////////////////////////////////////////////////////////////////////////////////////////
-        // countNonZero
-
-        namespace countnonzero
+        template <class Op>
+        static __device__ __forceinline__ const thrust::tuple<Op, Op> op(const Op& op)
         {
-            __constant__ int ctwidth;
-            __constant__ int ctheight;
-
-            __device__ uint blocks_finished = 0;
-
-            void estimateThreadCfg(int cols, int rows, dim3& threads, dim3& grid)
-            {
-                threads = dim3(32, 8);
-                grid = dim3(divUp(cols, threads.x * 8), divUp(rows, threads.y * 32));
-                grid.x = std::min(grid.x, threads.x);
-                grid.y = std::min(grid.y, threads.y);
-            }
-
-
-            void getBufSizeRequired(int cols, int rows, int& bufcols, int& bufrows)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(cols, rows, threads, grid);
-                bufcols = grid.x * grid.y * sizeof(int);
-                bufrows = 1;
-            }
-
-
-            void setKernelConsts(int cols, int rows, const dim3& threads, const dim3& grid)
-            {
-                int twidth = divUp(divUp(cols, grid.x), threads.x);
-                int theight = divUp(divUp(rows, grid.y), threads.y);
-                cudaSafeCall(cudaMemcpyToSymbol(ctwidth, &twidth, sizeof(twidth)));
-                cudaSafeCall(cudaMemcpyToSymbol(ctheight, &theight, sizeof(theight)));
-            }
-
-
-            template <int nthreads, typename T>
-            __global__ void countNonZeroKernel(const PtrStepSzb src, volatile uint* count)
-            {
-                __shared__ uint scount[nthreads];
-
-                uint x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                uint y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                uint cnt = 0;
-                for (uint y = 0; y < ctheight && y0 + y * blockDim.y < src.rows; ++y)
-                {
-                    const T* ptr = (const T*)src.ptr(y0 + y * blockDim.y);
-                    for (uint x = 0; x < ctwidth && x0 + x * blockDim.x < src.cols; ++x)
-                        cnt += ptr[x0 + x * blockDim.x] != 0;
-                }
-
-                scount[tid] = cnt;
-                __syncthreads();
-
-                sumInSmem<nthreads, uint>(scount, tid);
-
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    count[blockIdx.y * gridDim.x + blockIdx.x] = scount[0];
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = ticket == gridDim.x * gridDim.y - 1;
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    scount[tid] = tid < gridDim.x * gridDim.y ? count[tid] : 0;
-                    __syncthreads();
-
-                    sumInSmem<nthreads, uint>(scount, tid);
-
-                    if (tid == 0)
-                    {
-                        count[0] = scount[0];
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0) count[blockIdx.y * gridDim.x + blockIdx.x] = scount[0];
-            #endif
-            }
-
-
-            template <typename T>
-            int countNonZeroCaller(const PtrStepSzb src, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                uint* count_buf = (uint*)buf.ptr(0);
-
-                countNonZeroKernel<256, T><<<grid, threads>>>(src, count_buf);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                uint count;
-                cudaSafeCall(cudaMemcpy(&count, count_buf, sizeof(int), cudaMemcpyDeviceToHost));
-
-                return count;
-            }
-
-            template int countNonZeroCaller<uchar>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<char>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<ushort>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<short>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<int>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<float>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroCaller<double>(const PtrStepSzb, PtrStepb);
-
-
-            template <int nthreads, typename T>
-            __global__ void countNonZeroPass2Kernel(uint* count, int size)
-            {
-                __shared__ uint scount[nthreads];
-                uint tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                scount[tid] = tid < size ? count[tid] : 0;
-                __syncthreads();
-
-                sumInSmem<nthreads, uint>(scount, tid);
-
-                if (tid == 0)
-                    count[0] = scount[0];
-            }
-
-
-            template <typename T>
-            int countNonZeroMultipassCaller(const PtrStepSzb src, PtrStepb buf)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                uint* count_buf = (uint*)buf.ptr(0);
-
-                countNonZeroKernel<256, T><<<grid, threads>>>(src, count_buf);
-                cudaSafeCall( cudaGetLastError() );
-                countNonZeroPass2Kernel<256, T><<<1, 256>>>(count_buf, grid.x * grid.y);
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                uint count;
-                cudaSafeCall(cudaMemcpy(&count, count_buf, sizeof(int), cudaMemcpyDeviceToHost));
-
-                return count;
-            }
-
-            template int countNonZeroMultipassCaller<uchar>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroMultipassCaller<char>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroMultipassCaller<ushort>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroMultipassCaller<short>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroMultipassCaller<int>(const PtrStepSzb, PtrStepb);
-            template int countNonZeroMultipassCaller<float>(const PtrStepSzb, PtrStepb);
-
-        } // namespace countnonzero
-
-
-        //////////////////////////////////////////////////////////////////////////
-        // Sum
-
-        namespace sum
+            return thrust::make_tuple(op, op);
+        }
+    };
+    template <> struct Unroll<3>
+    {
+        template <int BLOCK_SIZE, typename R>
+        static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*, volatile R*> smem_tuple(R* smem)
         {
-            template <typename T> struct SumType {};
-            template <> struct SumType<uchar> { typedef uint R; };
-            template <> struct SumType<char> { typedef int R; };
-            template <> struct SumType<ushort> { typedef uint R; };
-            template <> struct SumType<short> { typedef int R; };
-            template <> struct SumType<int> { typedef int R; };
-            template <> struct SumType<float> { typedef float R; };
-            template <> struct SumType<double> { typedef double R; };
+            return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE);
+        }
 
-            template <typename R>
-            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); } };
-
-            template <>
-            struct AbsOp<uint> { static __device__ __forceinline__ uint call(uint x) { return x; } };
-
-            template <typename R>
-            struct SqrOp { static __device__ __forceinline__ R call(R x) { return x * x; } };
-
-            __constant__ int ctwidth;
-            __constant__ int ctheight;
-            __device__ uint blocks_finished = 0;
-
-            const int threads_x = 32;
-            const int threads_y = 8;
-
-            void estimateThreadCfg(int cols, int rows, dim3& threads, dim3& grid)
-            {
-                threads = dim3(threads_x, threads_y);
-                grid = dim3(divUp(cols, threads.x * threads.y),
-                            divUp(rows, threads.y * threads.x));
-                grid.x = std::min(grid.x, threads.x);
-                grid.y = std::min(grid.y, threads.y);
-            }
-
-
-            void getBufSizeRequired(int cols, int rows, int cn, int& bufcols, int& bufrows)
-            {
-                dim3 threads, grid;
-                estimateThreadCfg(cols, rows, threads, grid);
-                bufcols = grid.x * grid.y * sizeof(double) * cn;
-                bufrows = 1;
-            }
-
-
-            void setKernelConsts(int cols, int rows, const dim3& threads, const dim3& grid)
-            {
-                int twidth = divUp(divUp(cols, grid.x), threads.x);
-                int theight = divUp(divUp(rows, grid.y), threads.y);
-                cudaSafeCall(cudaMemcpyToSymbol(ctwidth, &twidth, sizeof(twidth)));
-                cudaSafeCall(cudaMemcpyToSymbol(ctheight, &theight, sizeof(theight)));
-            }
-
-            template <typename T, typename R, typename Op, int nthreads>
-            __global__ void sumKernel(const PtrStepSzb src, R* result)
-            {
-                __shared__ R smem[nthreads];
-
-                const int x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                const int y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-                const int bid = blockIdx.y * gridDim.x + blockIdx.x;
-
-                R sum = 0;
-                for (int y = 0; y < ctheight && y0 + y * blockDim.y < src.rows; ++y)
-                {
-                    const T* ptr = (const T*)src.ptr(y0 + y * blockDim.y);
-                    for (int x = 0; x < ctwidth && x0 + x * blockDim.x < src.cols; ++x)
-                        sum += Op::call(ptr[x0 + x * blockDim.x]);
-                }
-
-                smem[tid] = sum;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    result[bid] = smem[0];
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = (ticket == gridDim.x * gridDim.y - 1);
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    smem[tid] = tid < gridDim.x * gridDim.y ? result[tid] : 0;
-                    __syncthreads();
-
-                    sumInSmem<nthreads, R>(smem, tid);
-
-                    if (tid == 0)
-                    {
-                        result[0] = smem[0];
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0) result[bid] = smem[0];
-            #endif
-            }
-
-
-            template <typename T, typename R, int nthreads>
-            __global__ void sumPass2Kernel(R* result, int size)
-            {
-                __shared__ R smem[nthreads];
-                int tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                smem[tid] = tid < size ? result[tid] : 0;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-
-                if (tid == 0)
-                    result[0] = smem[0];
-            }
-
-
-            template <typename T, typename R, typename Op, int nthreads>
-            __global__ void sumKernel_C2(const PtrStepSzb src, typename TypeVec<R, 2>::vec_type* result)
-            {
-                typedef typename TypeVec<T, 2>::vec_type SrcType;
-                typedef typename TypeVec<R, 2>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 2];
-
-                const int x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                const int y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-                const int bid = blockIdx.y * gridDim.x + blockIdx.x;
-
-                SrcType val;
-                DstType sum = VecTraits<DstType>::all(0);
-                for (int y = 0; y < ctheight && y0 + y * blockDim.y < src.rows; ++y)
-                {
-                    const SrcType* ptr = (const SrcType*)src.ptr(y0 + y * blockDim.y);
-                    for (int x = 0; x < ctwidth && x0 + x * blockDim.x < src.cols; ++x)
-                    {
-                        val = ptr[x0 + x * blockDim.x];
-                        sum = sum + VecTraits<DstType>::make(Op::call(val.x), Op::call(val.y));
-                    }
-                }
-
-                smem[tid] = sum.x;
-                smem[tid + nthreads] = sum.y;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    result[bid] = res;
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = (ticket == gridDim.x * gridDim.y - 1);
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    DstType res = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<DstType>::all(0);
-                    smem[tid] = res.x;
-                    smem[tid + nthreads] = res.y;
-                    __syncthreads();
-
-                    sumInSmem<nthreads, R>(smem, tid);
-                    sumInSmem<nthreads, R>(smem + nthreads, tid);
-
-                    if (tid == 0)
-                    {
-                        res.x = smem[0];
-                        res.y = smem[nthreads];
-                        result[0] = res;
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    result[bid] = res;
-                }
-            #endif
-            }
-
-
-            template <typename T, typename R, int nthreads>
-            __global__ void sumPass2Kernel_C2(typename TypeVec<R, 2>::vec_type* result, int size)
-            {
-                typedef typename TypeVec<R, 2>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 2];
-
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                DstType res = tid < size ? result[tid] : VecTraits<DstType>::all(0);
-                smem[tid] = res.x;
-                smem[tid + nthreads] = res.y;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-
-                if (tid == 0)
-                {
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    result[0] = res;
-                }
-            }
-
-
-            template <typename T, typename R, typename Op, int nthreads>
-            __global__ void sumKernel_C3(const PtrStepSzb src, typename TypeVec<R, 3>::vec_type* result)
-            {
-                typedef typename TypeVec<T, 3>::vec_type SrcType;
-                typedef typename TypeVec<R, 3>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 3];
-
-                const int x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                const int y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-                const int bid = blockIdx.y * gridDim.x + blockIdx.x;
-
-                SrcType val;
-                DstType sum = VecTraits<DstType>::all(0);
-                for (int y = 0; y < ctheight && y0 + y * blockDim.y < src.rows; ++y)
-                {
-                    const SrcType* ptr = (const SrcType*)src.ptr(y0 + y * blockDim.y);
-                    for (int x = 0; x < ctwidth && x0 + x * blockDim.x < src.cols; ++x)
-                    {
-                        val = ptr[x0 + x * blockDim.x];
-                        sum = sum + VecTraits<DstType>::make(Op::call(val.x), Op::call(val.y), Op::call(val.z));
-                    }
-                }
-
-                smem[tid] = sum.x;
-                smem[tid + nthreads] = sum.y;
-                smem[tid + 2 * nthreads] = sum.z;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-
-            #if defined(__CUDA_ARCH__) && __CUDA_ARCH__ >= 110
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    result[bid] = res;
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = (ticket == gridDim.x * gridDim.y - 1);
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    DstType res = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<DstType>::all(0);
-                    smem[tid] = res.x;
-                    smem[tid + nthreads] = res.y;
-                    smem[tid + 2 * nthreads] = res.z;
-                    __syncthreads();
-
-                    sumInSmem<nthreads, R>(smem, tid);
-                    sumInSmem<nthreads, R>(smem + nthreads, tid);
-                    sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-
-                    if (tid == 0)
-                    {
-                        res.x = smem[0];
-                        res.y = smem[nthreads];
-                        res.z = smem[2 * nthreads];
-                        result[0] = res;
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    result[bid] = res;
-                }
-            #endif
-            }
-
-
-            template <typename T, typename R, int nthreads>
-            __global__ void sumPass2Kernel_C3(typename TypeVec<R, 3>::vec_type* result, int size)
-            {
-                typedef typename TypeVec<R, 3>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 3];
-
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                DstType res = tid < size ? result[tid] : VecTraits<DstType>::all(0);
-                smem[tid] = res.x;
-                smem[tid + nthreads] = res.y;
-                smem[tid + 2 * nthreads] = res.z;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-
-                if (tid == 0)
-                {
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    result[0] = res;
-                }
-            }
-
-            template <typename T, typename R, typename Op, int nthreads>
-            __global__ void sumKernel_C4(const PtrStepSzb src, typename TypeVec<R, 4>::vec_type* result)
-            {
-                typedef typename TypeVec<T, 4>::vec_type SrcType;
-                typedef typename TypeVec<R, 4>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 4];
-
-                const int x0 = blockIdx.x * blockDim.x * ctwidth + threadIdx.x;
-                const int y0 = blockIdx.y * blockDim.y * ctheight + threadIdx.y;
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-                const int bid = blockIdx.y * gridDim.x + blockIdx.x;
-
-                SrcType val;
-                DstType sum = VecTraits<DstType>::all(0);
-                for (int y = 0; y < ctheight && y0 + y * blockDim.y < src.rows; ++y)
-                {
-                    const SrcType* ptr = (const SrcType*)src.ptr(y0 + y * blockDim.y);
-                    for (int x = 0; x < ctwidth && x0 + x * blockDim.x < src.cols; ++x)
-                    {
-                        val = ptr[x0 + x * blockDim.x];
-                        sum = sum + VecTraits<DstType>::make(Op::call(val.x), Op::call(val.y),
-                                                             Op::call(val.z), Op::call(val.w));
-                    }
-                }
-
-                smem[tid] = sum.x;
-                smem[tid + nthreads] = sum.y;
-                smem[tid + 2 * nthreads] = sum.z;
-                smem[tid + 3 * nthreads] = sum.w;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 3 * nthreads, tid);
-
-            #if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
-                __shared__ bool is_last;
-
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    res.w = smem[3 * nthreads];
-                    result[bid] = res;
-                    __threadfence();
-
-                    uint ticket = atomicInc(&blocks_finished, gridDim.x * gridDim.y);
-                    is_last = (ticket == gridDim.x * gridDim.y - 1);
-                }
-
-                __syncthreads();
-
-                if (is_last)
-                {
-                    DstType res = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<DstType>::all(0);
-                    smem[tid] = res.x;
-                    smem[tid + nthreads] = res.y;
-                    smem[tid + 2 * nthreads] = res.z;
-                    smem[tid + 3 * nthreads] = res.w;
-                    __syncthreads();
-
-                    sumInSmem<nthreads, R>(smem, tid);
-                    sumInSmem<nthreads, R>(smem + nthreads, tid);
-                    sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-                    sumInSmem<nthreads, R>(smem + 3 * nthreads, tid);
-
-                    if (tid == 0)
-                    {
-                        res.x = smem[0];
-                        res.y = smem[nthreads];
-                        res.z = smem[2 * nthreads];
-                        res.w = smem[3 * nthreads];
-                        result[0] = res;
-                        blocks_finished = 0;
-                    }
-                }
-            #else
-                if (tid == 0)
-                {
-                    DstType res;
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    res.w = smem[3 * nthreads];
-                    result[bid] = res;
-                }
-            #endif
-            }
-
-
-            template <typename T, typename R, int nthreads>
-            __global__ void sumPass2Kernel_C4(typename TypeVec<R, 4>::vec_type* result, int size)
-            {
-                typedef typename TypeVec<R, 4>::vec_type DstType;
-
-                __shared__ R smem[nthreads * 4];
-
-                const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-
-                DstType res = tid < size ? result[tid] : VecTraits<DstType>::all(0);
-                smem[tid] = res.x;
-                smem[tid + nthreads] = res.y;
-                smem[tid + 2 * nthreads] = res.z;
-                smem[tid + 3 * nthreads] = res.w;
-                __syncthreads();
-
-                sumInSmem<nthreads, R>(smem, tid);
-                sumInSmem<nthreads, R>(smem + nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 2 * nthreads, tid);
-                sumInSmem<nthreads, R>(smem + 3 * nthreads, tid);
-
-                if (tid == 0)
-                {
-                    res.x = smem[0];
-                    res.y = smem[nthreads];
-                    res.z = smem[2 * nthreads];
-                    res.w = smem[3 * nthreads];
-                    result[0] = res;
-                }
-            }
-
-            template <typename T>
-            void sumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef typename SumType<T>::R R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                }
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(&result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void sumMultipassCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumMultipassCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumMultipassCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumMultipassCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumMultipassCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumMultipassCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-
-
-            template <typename T>
-            void sumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef typename SumType<T>::R R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, IdentityOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    break;
-                }
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(&result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void sumCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sumCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-
-
-            template <typename T>
-            void absSumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef typename SumType<T>::R R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                }
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void absSumMultipassCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumMultipassCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumMultipassCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumMultipassCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumMultipassCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumMultipassCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-
-
-            template <typename T>
-            void absSumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef typename SumType<T>::R R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, AbsOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    break;
-                }
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void absSumCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void absSumCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-
-
-            template <typename T>
-            void sqrSumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef typename SumType<T>::R R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 1>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C2<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 2>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C3<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 3>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    cudaSafeCall( cudaGetLastError() );
-
-                    sumPass2Kernel_C4<T, R, threads_x * threads_y><<<1, threads_x * threads_y>>>(
-                            (typename TypeVec<R, 4>::vec_type*)buf.ptr(0), grid.x * grid.y);
-                    cudaSafeCall( cudaGetLastError() );
-
-                    break;
-                }
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void sqrSumMultipassCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumMultipassCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumMultipassCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumMultipassCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumMultipassCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumMultipassCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-
-
-            template <typename T>
-            void sqrSumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn)
-            {
-                typedef double R;
-
-                dim3 threads, grid;
-                estimateThreadCfg(src.cols, src.rows, threads, grid);
-                setKernelConsts(src.cols, src.rows, threads, grid);
-
-                switch (cn)
-                {
-                case 1:
-                    sumKernel<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 1>::vec_type*)buf.ptr(0));
-                    break;
-                case 2:
-                    sumKernel_C2<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 2>::vec_type*)buf.ptr(0));
-                    break;
-                case 3:
-                    sumKernel_C3<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 3>::vec_type*)buf.ptr(0));
-                    break;
-                case 4:
-                    sumKernel_C4<T, R, SqrOp<R>, threads_x * threads_y><<<grid, threads>>>(
-                            src, (typename TypeVec<R, 4>::vec_type*)buf.ptr(0));
-                    break;
-                }
-                cudaSafeCall( cudaGetLastError() );
-
-                cudaSafeCall( cudaDeviceSynchronize() );
-
-                R result[4] = {0, 0, 0, 0};
-                cudaSafeCall(cudaMemcpy(result, buf.ptr(0), sizeof(R) * cn, cudaMemcpyDeviceToHost));
-
-                sum[0] = result[0];
-                sum[1] = result[1];
-                sum[2] = result[2];
-                sum[3] = result[3];
-            }
-
-            template void sqrSumCaller<uchar>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumCaller<char>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumCaller<ushort>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumCaller<short>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumCaller<int>(const PtrStepSzb, PtrStepb, double*, int);
-            template void sqrSumCaller<float>(const PtrStepSzb, PtrStepb, double*, int);
-        } // namespace sum
-
-        //////////////////////////////////////////////////////////////////////////////
-        // reduce
-
-        template <typename S> struct SumReductor
+        template <typename R>
+        static __device__ __forceinline__ thrust::tuple<typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&> tie(R& val)
         {
-            __device__ __forceinline__ S startValue() const
-            {
-                return 0;
-            }
+            return thrust::tie(val.x, val.y, val.z);
+        }
 
-            __device__ __forceinline__ SumReductor(const SumReductor& other){}
-            __device__ __forceinline__ SumReductor(){}
-
-            __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
+        template <class Op>
+        static __device__ __forceinline__ const thrust::tuple<Op, Op, Op> op(const Op& op)
         {
-            __device__ __forceinline__ S startValue() const
-            {
-                return 0;
-            }
-
-            __device__ __forceinline__ AvgReductor(const AvgReductor& other){}
-            __device__ __forceinline__ AvgReductor(){}
-
-            __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
+            return thrust::make_tuple(op, op, op);
+        }
+    };
+    template <> struct Unroll<4>
+    {
+        template <int BLOCK_SIZE, typename R>
+        static __device__ __forceinline__ thrust::tuple<volatile R*, volatile R*, volatile R*, volatile R*> smem_tuple(R* smem)
         {
-            __device__ __forceinline__ S startValue() const
-            {
-                return numeric_limits<S>::max();
-            }
+            return cv::gpu::device::smem_tuple(smem, smem + BLOCK_SIZE, smem + 2 * BLOCK_SIZE, smem + 3 * BLOCK_SIZE);
+        }
 
-            __device__ __forceinline__ MinReductor(const MinReductor& other){}
-            __device__ __forceinline__ MinReductor(){}
-
-            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
+        template <typename R>
+        static __device__ __forceinline__ thrust::tuple<typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&, typename VecTraits<R>::elem_type&> tie(R& val)
         {
-            __device__ __forceinline__ S startValue() const
-            {
-                return numeric_limits<S>::min();
-            }
+            return thrust::tie(val.x, val.y, val.z, val.w);
+        }
 
-            __device__ __forceinline__ MaxReductor(const MaxReductor& other){}
-            __device__ __forceinline__ MaxReductor(){}
-
-            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 PtrStepSz<T> src, D* dst, const Op op)
+        template <class Op>
+        static __device__ __forceinline__ const thrust::tuple<Op, Op, Op, Op> op(const Op& op)
         {
-            __shared__ S smem[16 * 16];
+            return thrust::make_tuple(op, op, op, op);
+        }
+    };
+}
 
-            const int x = blockIdx.x * 16 + threadIdx.x;
+/////////////////////////////////////////////////////////////
+// sum
 
-            S myVal = op.startValue();
+namespace sum
+{
+    __device__ unsigned int blocks_finished = 0;
 
-            if (x < src.cols)
+    template <typename R, int cn> struct AtomicAdd;
+    template <typename R> struct AtomicAdd<R, 1>
+    {
+        static __device__ void run(R* ptr, R val)
+        {
+            ::atomicAdd(ptr, val);
+        }
+    };
+    template <typename R> struct AtomicAdd<R, 2>
+    {
+        typedef typename TypeVec<R, 2>::vec_type val_type;
+
+        static __device__ void run(R* ptr, val_type val)
+        {
+            ::atomicAdd(ptr, val.x);
+            ::atomicAdd(ptr + 1, val.y);
+        }
+    };
+    template <typename R> struct AtomicAdd<R, 3>
+    {
+        typedef typename TypeVec<R, 3>::vec_type val_type;
+
+        static __device__ void run(R* ptr, val_type val)
+        {
+            ::atomicAdd(ptr, val.x);
+            ::atomicAdd(ptr + 1, val.y);
+            ::atomicAdd(ptr + 2, val.z);
+        }
+    };
+    template <typename R> struct AtomicAdd<R, 4>
+    {
+        typedef typename TypeVec<R, 4>::vec_type val_type;
+
+        static __device__ void run(R* ptr, val_type val)
+        {
+            ::atomicAdd(ptr, val.x);
+            ::atomicAdd(ptr + 1, val.y);
+            ::atomicAdd(ptr + 2, val.z);
+            ::atomicAdd(ptr + 3, val.w);
+        }
+    };
+
+    template <int BLOCK_SIZE, typename R, int cn>
+    struct GlobalReduce
+    {
+        typedef typename TypeVec<R, cn>::vec_type result_type;
+
+        static __device__ void run(result_type& sum, result_type* result, int tid, int bid, R* smem)
+        {
+        #if __CUDA_ARCH__ >= 200
+            if (tid == 0)
+                AtomicAdd<R, cn>::run((R*) result, sum);
+        #else
+            __shared__ bool is_last;
+
+            if (tid == 0)
             {
-                for (int y = threadIdx.y; y < src.rows; y += 16)
-                    myVal = op(myVal, src.ptr(y)[x]);
+                result[bid] = sum;
+
+                __threadfence();
+
+                unsigned int ticket = ::atomicAdd(&blocks_finished, 1);
+                is_last = (ticket == gridDim.x * gridDim.y - 1);
             }
 
-            smem[threadIdx.x * 16 + threadIdx.y] = myVal;
             __syncthreads();
 
-            if (threadIdx.x < 8)
+            if (is_last)
             {
-                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();
+                sum = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<result_type>::all(0);
 
-            if (threadIdx.y == 0 && x < src.cols)
-                dst[x] = saturate_cast<D>(op.result(smem[threadIdx.x * 16], src.rows));
-        }
+                device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<R>()));
 
-        template <template <typename> class Op, typename T, typename S, typename D> void reduceRows_caller(const PtrStepSz<T>& src, PtrStepSz<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 PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream)
-        {
-            typedef void (*caller_t)(const PtrStepSz<T>& src, PtrStepSz<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< PtrStepSz<T> >(src), static_cast< PtrStepSz<D> >(dst), stream);
-        }
-
-        template void reduceRows_gpu<uchar, int, uchar>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<uchar, int, int>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<uchar, int, float>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        template void reduceRows_gpu<ushort, int, ushort>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<ushort, int, int>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<ushort, int, float>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        template void reduceRows_gpu<short, int, short>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<short, int, int>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<short, int, float>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        template void reduceRows_gpu<int, int, int>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceRows_gpu<int, int, float>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        template void reduceRows_gpu<float, float, float>(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-
-
-        template <int cn, class Op, typename T, typename S, typename D> __global__ void reduceCols(const PtrStepSz<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 defined (__CUDA_ARCH__) && __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]);
-            }
-
-        #else // __CUDA_ARCH__ >= 200
-
-            // 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)
+                if (tid == 0)
                 {
-                    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();
-            }
-
-        #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)
-            {
-                #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]);
+                    result[0] = sum;
+                    blocks_finished = 0;
                 }
             }
+        #endif
+        }
+    };
+    template <int BLOCK_SIZE, int cn>
+    struct GlobalReduce<BLOCK_SIZE, double, cn>
+    {
+        typedef typename TypeVec<double, cn>::vec_type result_type;
+
+        static __device__ void run(result_type& sum, result_type* result, int tid, int bid, double* smem)
+        {
+            __shared__ bool is_last;
+
+            if (tid == 0)
+            {
+                result[bid] = sum;
+
+                __threadfence();
+
+                unsigned int ticket = ::atomicAdd(&blocks_finished, 1);
+                is_last = (ticket == gridDim.x * gridDim.y - 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 PtrStepSz<T>& src, PtrStepSz<D> dst, cudaStream_t stream)
-        {
-            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() );
-
-        }
-
-        template <typename T, typename S, typename D> void reduceCols_gpu(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream)
-        {
-            typedef void (*caller_t)(const PtrStepSz<T>& src, PtrStepSz<D> dst, cudaStream_t stream);
-
-            static const caller_t callers[4][4] =
+            if (is_last)
             {
-                {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>},
-            };
+                sum = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<result_type>::all(0);
 
-            callers[cn - 1][reduceOp](static_cast< PtrStepSz<T> >(src), static_cast< PtrStepSz<D> >(dst), stream);
+                device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<double>()));
+
+                if (tid == 0)
+                {
+                    result[0] = sum;
+                    blocks_finished = 0;
+                }
+            }
+        }
+    };
+
+    template <int BLOCK_SIZE, typename src_type, typename result_type, class Op>
+    __global__ void kernel(const PtrStepSz<src_type> src, result_type* result, const Op op, const int twidth, const int theight)
+    {
+        typedef typename VecTraits<src_type>::elem_type T;
+        typedef typename VecTraits<result_type>::elem_type R;
+        const int cn = VecTraits<src_type>::cn;
+
+        __shared__ R smem[BLOCK_SIZE * cn];
+
+        const int x0 = blockIdx.x * blockDim.x * twidth + threadIdx.x;
+        const int y0 = blockIdx.y * blockDim.y * theight + threadIdx.y;
+
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
+
+        result_type sum = VecTraits<result_type>::all(0);
+
+        for (int i = 0, y = y0; i < theight && y < src.rows; ++i, y += blockDim.y)
+        {
+            const src_type* ptr = src.ptr(y);
+
+            for (int j = 0, x = x0; j < twidth && x < src.cols; ++j, x += blockDim.x)
+            {
+                const src_type srcVal = ptr[x];
+
+                sum = sum + op(saturate_cast<result_type>(srcVal));
+            }
         }
 
-        template void reduceCols_gpu<uchar, int, uchar>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<uchar, int, int>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<uchar, int, float>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
+        device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<R>()));
 
-        template void reduceCols_gpu<ushort, int, ushort>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<ushort, int, int>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<ushort, int, float>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
+        GlobalReduce<BLOCK_SIZE, R, cn>::run(sum, result, tid, bid, smem);
+    }
 
-        template void reduceCols_gpu<short, int, short>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<short, int, int>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<short, int, float>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
+    const int threads_x = 32;
+    const int threads_y = 8;
 
-        template void reduceCols_gpu<int, int, int>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template void reduceCols_gpu<int, int, float>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
+    void getLaunchCfg(int cols, int rows, dim3& block, dim3& grid)
+    {
+        block = dim3(threads_x, threads_y);
 
-        template void reduceCols_gpu<float, float, float>(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-    } // namespace mattrix_reductions
-}}} // namespace cv { namespace gpu { namespace device
+        grid = dim3(divUp(cols, block.x * block.y),
+                    divUp(rows, block.y * block.x));
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+        grid.x = ::min(grid.x, block.x);
+        grid.y = ::min(grid.y, block.y);
+    }
+
+    void getBufSize(int cols, int rows, int cn, int& bufcols, int& bufrows)
+    {
+        dim3 block, grid;
+        getLaunchCfg(cols, rows, block, grid);
+
+        bufcols = grid.x * grid.y * sizeof(double) * cn;
+        bufrows = 1;
+    }
+
+    template <typename T, typename R, int cn, template <typename> class Op>
+    void caller(PtrStepSzb src_, void* buf_, double* out)
+    {
+        typedef typename TypeVec<T, cn>::vec_type src_type;
+        typedef typename TypeVec<R, cn>::vec_type result_type;
+
+        PtrStepSz<src_type> src(src_);
+        result_type* buf = (result_type*) buf_;
+
+        dim3 block, grid;
+        getLaunchCfg(src.cols, src.rows, block, grid);
+
+        const int twidth = divUp(divUp(src.cols, grid.x), block.x);
+        const int theight = divUp(divUp(src.rows, grid.y), block.y);
+
+        Op<result_type> op;
+
+        kernel<threads_x * threads_y><<<grid, block>>>(src, buf, op, twidth, theight);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+        R result[4] = {0, 0, 0, 0};
+        cudaSafeCall( cudaMemcpy(&result, buf, sizeof(result_type), cudaMemcpyDeviceToHost) );
+
+        out[0] = result[0];
+        out[1] = result[1];
+        out[2] = result[2];
+        out[3] = result[3];
+    }
+
+    template <typename T> struct SumType;
+    template <> struct SumType<uchar> { typedef unsigned int R; };
+    template <> struct SumType<schar> { typedef int R; };
+    template <> struct SumType<ushort> { typedef unsigned int R; };
+    template <> struct SumType<short> { typedef int R; };
+    template <> struct SumType<int> { typedef int R; };
+    template <> struct SumType<float> { typedef float R; };
+    template <> struct SumType<double> { typedef double R; };
+
+    template <typename T, int cn>
+    void run(PtrStepSzb src, void* buf, double* out)
+    {
+        typedef typename SumType<T>::R R;
+        caller<T, R, cn, identity>(src, buf, out);
+    }
+
+    template void run<uchar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<uchar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<uchar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<uchar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<schar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<schar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<schar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<schar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<ushort, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<ushort, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<ushort, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<ushort, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<short, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<short, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<short, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<short, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<int, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<int, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<int, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<int, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<float, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<float, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<float, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<float, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void run<double, 1>(PtrStepSzb src, void* buf, double* out);
+    template void run<double, 2>(PtrStepSzb src, void* buf, double* out);
+    template void run<double, 3>(PtrStepSzb src, void* buf, double* out);
+    template void run<double, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template <typename T, int cn>
+    void runAbs(PtrStepSzb src, void* buf, double* out)
+    {
+        typedef typename SumType<T>::R R;
+        caller<T, R, cn, abs_func>(src, buf, out);
+    }
+
+    template void runAbs<uchar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<uchar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<uchar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<uchar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<schar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<schar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<schar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<schar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<ushort, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<ushort, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<ushort, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<ushort, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<short, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<short, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<short, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<short, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<int, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<int, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<int, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<int, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<float, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<float, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<float, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<float, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runAbs<double, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<double, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<double, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runAbs<double, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template <typename T> struct Sqr : unary_function<T, T>
+    {
+        __device__ __forceinline__ T operator ()(T x) const
+        {
+            return x * x;
+        }
+    };
+
+    template <typename T, int cn>
+    void runSqr(PtrStepSzb src, void* buf, double* out)
+    {
+        caller<T, double, cn, Sqr>(src, buf, out);
+    }
+
+    template void runSqr<uchar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<uchar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<uchar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<uchar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<schar, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<schar, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<schar, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<schar, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<ushort, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<ushort, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<ushort, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<ushort, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<short, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<short, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<short, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<short, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<int, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<int, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<int, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<int, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<float, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<float, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<float, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<float, 4>(PtrStepSzb src, void* buf, double* out);
+
+    template void runSqr<double, 1>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<double, 2>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<double, 3>(PtrStepSzb src, void* buf, double* out);
+    template void runSqr<double, 4>(PtrStepSzb src, void* buf, double* out);
+}
+
+/////////////////////////////////////////////////////////////
+// minMax
+
+namespace minMax
+{
+    __device__ unsigned int blocks_finished = 0;
+
+    // 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<schar> { 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; };
+
+    template <int BLOCK_SIZE, typename R>
+    struct GlobalReduce
+    {
+        static __device__ void run(R& mymin, R& mymax, R* minval, R* maxval, int tid, int bid, R* sminval, R* smaxval)
+        {
+            __shared__ bool is_last;
+
+            if (tid == 0)
+            {
+                minval[bid] = mymin;
+                maxval[bid] = mymax;
+
+                __threadfence();
+
+                unsigned int ticket = ::atomicAdd(&blocks_finished, 1);
+                is_last = (ticket == gridDim.x * gridDim.y - 1);
+            }
+
+            __syncthreads();
+
+            if (is_last)
+            {
+                int idx = ::min(tid, gridDim.x * gridDim.y - 1);
+
+                mymin = minval[idx];
+                mymax = maxval[idx];
+
+                const minimum<R> minOp;
+                const maximum<R> maxOp;
+                device::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
+
+                if (tid == 0)
+                {
+                    minval[0] = mymin;
+                    maxval[0] = mymax;
+
+                    blocks_finished = 0;
+                }
+            }
+        }
+    };
+    template <int BLOCK_SIZE>
+    struct GlobalReduce<BLOCK_SIZE, int>
+    {
+        static __device__ void run(int& mymin, int& mymax, int* minval, int* maxval, int tid, int bid, int* sminval, int* smaxval)
+        {
+        #if __CUDA_ARCH__ >= 200
+            if (tid == 0)
+            {
+                ::atomicMin(minval, mymin);
+                ::atomicMax(maxval, mymax);
+            }
+        #else
+            __shared__ bool is_last;
+
+            if (tid == 0)
+            {
+                minval[bid] = mymin;
+                maxval[bid] = mymax;
+
+                __threadfence();
+
+                unsigned int ticket = ::atomicAdd(&blocks_finished, 1);
+                is_last = (ticket == gridDim.x * gridDim.y - 1);
+            }
+
+            __syncthreads();
+
+            if (is_last)
+            {
+                int idx = ::min(tid, gridDim.x * gridDim.y - 1);
+
+                mymin = minval[idx];
+                mymax = maxval[idx];
+
+                const minimum<int> minOp;
+                const maximum<int> maxOp;
+                device::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
+
+                if (tid == 0)
+                {
+                    minval[0] = mymin;
+                    maxval[0] = mymax;
+
+                    blocks_finished = 0;
+                }
+            }
+        #endif
+        }
+    };
+
+    template <int BLOCK_SIZE, typename T, typename R, class Mask>
+    __global__ void kernel(const PtrStepSz<T> src, const Mask mask, R* minval, R* maxval, const int twidth, const int theight)
+    {
+        __shared__ R sminval[BLOCK_SIZE];
+        __shared__ R smaxval[BLOCK_SIZE];
+
+        const int x0 = blockIdx.x * blockDim.x * twidth + threadIdx.x;
+        const int y0 = blockIdx.y * blockDim.y * theight + threadIdx.y;
+
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
+
+        R mymin = numeric_limits<R>::max();
+        R mymax = -numeric_limits<R>::max();
+
+        const minimum<R> minOp;
+        const maximum<R> maxOp;
+
+        for (int i = 0, y = y0; i < theight && y < src.rows; ++i, y += blockDim.y)
+        {
+            const T* ptr = src.ptr(y);
+
+            for (int j = 0, x = x0; j < twidth && x < src.cols; ++j, x += blockDim.x)
+            {
+                if (mask(y, x))
+                {
+                    const R srcVal = ptr[x];
+
+                    mymin = minOp(mymin, srcVal);
+                    mymax = maxOp(mymax, srcVal);
+                }
+            }
+        }
+
+        device::reduce<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax), tid, thrust::make_tuple(minOp, maxOp));
+
+        GlobalReduce<BLOCK_SIZE, R>::run(mymin, mymax, minval, maxval, tid, bid, sminval, smaxval);
+    }
+
+    const int threads_x = 32;
+    const int threads_y = 8;
+
+    void getLaunchCfg(int cols, int rows, dim3& block, dim3& grid)
+    {
+        block = dim3(threads_x, threads_y);
+
+        grid = dim3(divUp(cols, block.x * block.y),
+                    divUp(rows, block.y * block.x));
+
+        grid.x = ::min(grid.x, block.x);
+        grid.y = ::min(grid.y, block.y);
+    }
+
+    void getBufSize(int cols, int rows, int& bufcols, int& bufrows)
+    {
+        dim3 block, grid;
+        getLaunchCfg(cols, rows, block, grid);
+
+        bufcols = grid.x * grid.y * sizeof(double);
+        bufrows = 2;
+    }
+
+    __global__ void setDefaultKernel(int* minval_buf, int* maxval_buf)
+    {
+        *minval_buf = numeric_limits<int>::max();
+        *maxval_buf = numeric_limits<int>::min();
+    }
+
+    template <typename R>
+    void setDefault(R*, R*)
+    {
+    }
+    void setDefault(int* minval_buf, int* maxval_buf)
+    {
+        setDefaultKernel<<<1, 1>>>(minval_buf, maxval_buf);
+    }
+
+    template <typename T>
+    void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf)
+    {
+        typedef typename MinMaxTypeTraits<T>::best_type R;
+
+        dim3 block, grid;
+        getLaunchCfg(src.cols, src.rows, block, grid);
+
+        const int twidth = divUp(divUp(src.cols, grid.x), block.x);
+        const int theight = divUp(divUp(src.rows, grid.y), block.y);
+
+        R* minval_buf = (R*) buf.ptr(0);
+        R* maxval_buf = (R*) buf.ptr(1);
+
+        setDefault(minval_buf, maxval_buf);
+
+        if (mask.data)
+            kernel<threads_x * threads_y><<<grid, block>>>((PtrStepSz<T>) src, SingleMask(mask), minval_buf, maxval_buf, twidth, theight);
+        else
+            kernel<threads_x * threads_y><<<grid, block>>>((PtrStepSz<T>) src, WithOutMask(), minval_buf, maxval_buf, twidth, theight);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+        R minval_, maxval_;
+        cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(R), cudaMemcpyDeviceToHost) );
+        cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(R), cudaMemcpyDeviceToHost) );
+        *minval = minval_;
+        *maxval = maxval_;
+    }
+
+    template void run<uchar >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<schar >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<ushort>(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<short >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<int   >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<float >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    template void run<double>(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+}
+
+/////////////////////////////////////////////////////////////
+// minMaxLoc
+
+namespace minMaxLoc
+{
+    __device__ unsigned int blocks_finished = 0;
+
+    // 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<schar> { 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; };
+
+    template <int BLOCK_SIZE, typename T, class Mask>
+    __global__ void kernel(const PtrStepSz<T> src, const Mask mask, T* minval, T* maxval, unsigned int* minloc, unsigned int* maxloc, const int twidth, const int theight)
+    {
+        typedef typename MinMaxTypeTraits<T>::best_type work_type;
+
+        __shared__ work_type sminval[BLOCK_SIZE];
+        __shared__ work_type smaxval[BLOCK_SIZE];
+        __shared__ unsigned int sminloc[BLOCK_SIZE];
+        __shared__ unsigned int smaxloc[BLOCK_SIZE];
+        __shared__ bool is_last;
+
+        const int x0 = blockIdx.x * blockDim.x * twidth + threadIdx.x;
+        const int y0 = blockIdx.y * blockDim.y * theight + threadIdx.y;
+
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
+
+        work_type mymin = numeric_limits<work_type>::max();
+        work_type mymax = -numeric_limits<work_type>::max();
+        unsigned int myminloc = 0;
+        unsigned int mymaxloc = 0;
+
+        for (int i = 0, y = y0; i < theight && y < src.rows; ++i, y += blockDim.y)
+        {
+            const T* ptr = src.ptr(y);
+
+            for (int j = 0, x = x0; j < twidth && x < src.cols; ++j, x += blockDim.x)
+            {
+                if (mask(y, x))
+                {
+                    const work_type srcVal = ptr[x];
+
+                    if (srcVal < mymin)
+                    {
+                        mymin = srcVal;
+                        myminloc = y * src.cols + x;
+                    }
+
+                    if (srcVal > mymax)
+                    {
+                        mymax = srcVal;
+                        mymaxloc = y * src.cols + x;
+                    }
+                }
+            }
+        }
+
+        reduceKeyVal<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax),
+                                 smem_tuple(sminloc, smaxloc), thrust::tie(myminloc, mymaxloc),
+                                 tid,
+                                 thrust::make_tuple(less<work_type>(), greater<work_type>()));
+
+        if (tid == 0)
+        {
+            minval[bid] = (T) mymin;
+            maxval[bid] = (T) mymax;
+            minloc[bid] = myminloc;
+            maxloc[bid] = mymaxloc;
+
+            __threadfence();
+
+            unsigned int ticket = ::atomicInc(&blocks_finished, gridDim.x * gridDim.y);
+            is_last = (ticket == gridDim.x * gridDim.y - 1);
+        }
+
+        __syncthreads();
+
+        if (is_last)
+        {
+            unsigned int idx = ::min(tid, gridDim.x * gridDim.y - 1);
+
+            mymin = minval[idx];
+            mymax = maxval[idx];
+            myminloc = minloc[idx];
+            mymaxloc = maxloc[idx];
+
+            reduceKeyVal<BLOCK_SIZE>(smem_tuple(sminval, smaxval), thrust::tie(mymin, mymax),
+                                     smem_tuple(sminloc, smaxloc), thrust::tie(myminloc, mymaxloc),
+                                     tid,
+                                     thrust::make_tuple(less<work_type>(), greater<work_type>()));
+
+            if (tid == 0)
+            {
+                minval[0] = (T) mymin;
+                maxval[0] = (T) mymax;
+                minloc[0] = myminloc;
+                maxloc[0] = mymaxloc;
+
+                blocks_finished = 0;
+            }
+        }
+    }
+
+    const int threads_x = 32;
+    const int threads_y = 8;
+
+    void getLaunchCfg(int cols, int rows, dim3& block, dim3& grid)
+    {
+        block = dim3(threads_x, threads_y);
+
+        grid = dim3(divUp(cols, block.x * block.y),
+                    divUp(rows, block.y * block.x));
+
+        grid.x = ::min(grid.x, block.x);
+        grid.y = ::min(grid.y, block.y);
+    }
+
+    void getBufSize(int cols, int rows, size_t elem_size, int& b1cols, int& b1rows, int& b2cols, int& b2rows)
+    {
+        dim3 block, grid;
+        getLaunchCfg(cols, rows, block, grid);
+
+        // For values
+        b1cols = grid.x * grid.y * elem_size;
+        b1rows = 2;
+
+        // For locations
+        b2cols = grid.x * grid.y * sizeof(int);
+        b2rows = 2;
+    }
+
+    template <typename T>
+    void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf)
+    {
+        dim3 block, grid;
+        getLaunchCfg(src.cols, src.rows, block, grid);
+
+        const int twidth = divUp(divUp(src.cols, grid.x), block.x);
+        const int theight = divUp(divUp(src.rows, grid.y), block.y);
+
+        T* minval_buf = (T*) valbuf.ptr(0);
+        T* maxval_buf = (T*) valbuf.ptr(1);
+        unsigned int* minloc_buf = locbuf.ptr(0);
+        unsigned int* maxloc_buf = locbuf.ptr(1);
+
+        if (mask.data)
+            kernel<threads_x * threads_y><<<grid, block>>>((PtrStepSz<T>) src, SingleMask(mask), minval_buf, maxval_buf, minloc_buf, maxloc_buf, twidth, theight);
+        else
+            kernel<threads_x * threads_y><<<grid, block>>>((PtrStepSz<T>) src, WithOutMask(), minval_buf, maxval_buf, minloc_buf, maxloc_buf, twidth, theight);
+
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+        T minval_, maxval_;
+        cudaSafeCall( cudaMemcpy(&minval_, minval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
+        cudaSafeCall( cudaMemcpy(&maxval_, maxval_buf, sizeof(T), cudaMemcpyDeviceToHost) );
+        *minval = minval_;
+        *maxval = maxval_;
+
+        unsigned int minloc_, maxloc_;
+        cudaSafeCall( cudaMemcpy(&minloc_, minloc_buf, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+        cudaSafeCall( cudaMemcpy(&maxloc_, maxloc_buf, sizeof(unsigned int), cudaMemcpyDeviceToHost) );
+        minloc[1] = minloc_ / src.cols; minloc[0] = minloc_ - minloc[1] * src.cols;
+        maxloc[1] = maxloc_ / src.cols; maxloc[0] = maxloc_ - maxloc[1] * src.cols;
+    }
+
+    template void run<uchar >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<schar >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<ushort>(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<short >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<int   >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<float >(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    template void run<double>(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+}
+
+/////////////////////////////////////////////////////////////
+// countNonZero
+
+namespace countNonZero
+{
+    __device__ unsigned int blocks_finished = 0;
+
+    template <int BLOCK_SIZE, typename T>
+    __global__ void kernel(const PtrStepSz<T> src, unsigned int* count, const int twidth, const int theight)
+    {
+        __shared__ unsigned int scount[BLOCK_SIZE];
+        __shared__ bool is_last;
+
+        const int x0 = blockIdx.x * blockDim.x * twidth + threadIdx.x;
+        const int y0 = blockIdx.y * blockDim.y * theight + threadIdx.y;
+
+        const int tid = threadIdx.y * blockDim.x + threadIdx.x;
+        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
+
+        unsigned int mycount = 0;
+
+        for (int i = 0, y = y0; i < theight && y < src.rows; ++i, y += blockDim.y)
+        {
+            const T* ptr = src.ptr(y);
+
+            for (int j = 0, x = x0; j < twidth && x < src.cols; ++j, x += blockDim.x)
+            {
+                const T srcVal = ptr[x];
+
+                mycount += (srcVal != 0);
+            }
+        }
+
+        device::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
+
+    #if __CUDA_ARCH__ >= 200
+        if (tid == 0)
+            ::atomicAdd(count, mycount);
+    #else
+        if (tid == 0)
+        {
+            count[bid] = mycount;
+
+            __threadfence();
+
+            unsigned int ticket = ::atomicInc(&blocks_finished, gridDim.x * gridDim.y);
+            is_last = (ticket == gridDim.x * gridDim.y - 1);
+        }
+
+        __syncthreads();
+
+        if (is_last)
+        {
+            mycount = tid < gridDim.x * gridDim.y ? count[tid] : 0;
+
+            device::reduce<BLOCK_SIZE>(scount, mycount, tid, plus<unsigned int>());
+
+            if (tid == 0)
+            {
+                count[0] = mycount;
+
+                blocks_finished = 0;
+            }
+        }
+    #endif
+    }
+
+    const int threads_x = 32;
+    const int threads_y = 8;
+
+    void getLaunchCfg(int cols, int rows, dim3& block, dim3& grid)
+    {
+        block = dim3(threads_x, threads_y);
+
+        grid = dim3(divUp(cols, block.x * block.y),
+                    divUp(rows, block.y * block.x));
+
+        grid.x = ::min(grid.x, block.x);
+        grid.y = ::min(grid.y, block.y);
+    }
+
+    void getBufSize(int cols, int rows, int& bufcols, int& bufrows)
+    {
+        dim3 block, grid;
+        getLaunchCfg(cols, rows, block, grid);
+
+        bufcols = grid.x * grid.y * sizeof(int);
+        bufrows = 1;
+    }
+
+    template <typename T>
+    int run(const PtrStepSzb src, PtrStep<unsigned int> buf)
+    {
+        dim3 block, grid;
+        getLaunchCfg(src.cols, src.rows, block, grid);
+
+        const int twidth = divUp(divUp(src.cols, grid.x), block.x);
+        const int theight = divUp(divUp(src.rows, grid.y), block.y);
+
+        unsigned int* count_buf = buf.ptr(0);
+
+        cudaSafeCall( cudaMemset(count_buf, 0, sizeof(unsigned int)) );
+
+        kernel<threads_x * threads_y><<<grid, block>>>((PtrStepSz<T>) src, count_buf, twidth, theight);
+        cudaSafeCall( cudaGetLastError() );
+
+        cudaSafeCall( cudaDeviceSynchronize() );
+
+        unsigned int count;
+        cudaSafeCall(cudaMemcpy(&count, count_buf, sizeof(unsigned int), cudaMemcpyDeviceToHost));
+
+        return count;
+    }
+
+    template int run<uchar >(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<schar >(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<ushort>(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<short >(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<int   >(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<float >(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    template int run<double>(const PtrStepSzb src, PtrStep<unsigned int> buf);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// reduce
+
+namespace reduce
+{
+    struct Sum
+    {
+        template <typename T>
+        __device__ __forceinline__ T startValue() const
+        {
+            return VecTraits<T>::all(0);
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T operator ()(T a, T b) const
+        {
+            return a + b;
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T result(T r, double) const
+        {
+            return r;
+        }
+
+        __device__ __forceinline__ Sum() {}
+        __device__ __forceinline__ Sum(const Sum&) {}
+    };
+
+    struct Avg
+    {
+        template <typename T>
+        __device__ __forceinline__ T startValue() const
+        {
+            return VecTraits<T>::all(0);
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T operator ()(T a, T b) const
+        {
+            return a + b;
+        }
+
+        template <typename T>
+        __device__ __forceinline__ typename TypeVec<double, VecTraits<T>::cn>::vec_type result(T r, double sz) const
+        {
+            return r / sz;
+        }
+
+        __device__ __forceinline__ Avg() {}
+        __device__ __forceinline__ Avg(const Avg&) {}
+    };
+
+    struct Min
+    {
+        template <typename T>
+        __device__ __forceinline__ T startValue() const
+        {
+            return VecTraits<T>::all(numeric_limits<typename VecTraits<T>::elem_type>::max());
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T operator ()(T a, T b) const
+        {
+            minimum<T> minOp;
+            return minOp(a, b);
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T result(T r, double) const
+        {
+            return r;
+        }
+
+        __device__ __forceinline__ Min() {}
+        __device__ __forceinline__ Min(const Min&) {}
+    };
+
+    struct Max
+    {
+        template <typename T>
+        __device__ __forceinline__ T startValue() const
+        {
+            return VecTraits<T>::all(-numeric_limits<typename VecTraits<T>::elem_type>::max());
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T operator ()(T a, T b) const
+        {
+            maximum<T> maxOp;
+            return maxOp(a, b);
+        }
+
+        template <typename T>
+        __device__ __forceinline__ T result(T r, double) const
+        {
+            return r;
+        }
+
+        __device__ __forceinline__ Max() {}
+        __device__ __forceinline__ Max(const Max&) {}
+    };
+
+    ///////////////////////////////////////////////////////////
+
+    template <typename T, typename S, typename D, class Op>
+    __global__ void rowsKernel(const PtrStepSz<T> src, D* dst, const Op op)
+    {
+        __shared__ S smem[16 * 16];
+
+        const int x = blockIdx.x * 16 + threadIdx.x;
+
+        S myVal = op.template startValue<S>();
+
+        if (x < src.cols)
+        {
+            for (int y = threadIdx.y; y < src.rows; y += 16)
+            {
+                S srcVal = src(y, x);
+                myVal = op(myVal, srcVal);
+            }
+        }
+
+        smem[threadIdx.x * 16 + threadIdx.y] = myVal;
+
+        __syncthreads();
+
+        volatile S* srow = smem + threadIdx.y * 16;
+
+        myVal = srow[threadIdx.x];
+        device::reduce<16>(srow, myVal, threadIdx.x, op);
+
+        if (threadIdx.x == 0)
+            srow[0] = myVal;
+
+        __syncthreads();
+
+        if (threadIdx.y == 0 && x < src.cols)
+            dst[x] = (D) op.result(smem[threadIdx.x * 16], src.rows);
+    }
+
+    template <typename T, typename S, typename D, class Op>
+    void rowsCaller(PtrStepSz<T> src, D* dst, cudaStream_t stream)
+    {
+        const dim3 block(16, 16);
+        const dim3 grid(divUp(src.cols, block.x));
+
+        Op op;
+        rowsKernel<T, S, D, Op><<<grid, block, 0, stream>>>(src, dst, op);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template <typename T, typename S, typename D>
+    void rows(PtrStepSzb src, void* dst, int op, cudaStream_t stream)
+    {
+        typedef void (*func_t)(PtrStepSz<T> src, D* dst, cudaStream_t stream);
+        static const func_t funcs[] =
+        {
+            rowsCaller<T, S, D, Sum>,
+            rowsCaller<T, S, D, Avg>,
+            rowsCaller<T, S, D, Max>,
+            rowsCaller<T, S, D, Min>
+        };
+
+        funcs[op]((PtrStepSz<T>) src, (D*) dst, stream);
+    }
+
+    template void rows<unsigned char, int, unsigned char>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned char, int, int>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned char, float, float>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned char, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template void rows<unsigned short, int, unsigned short>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned short, int, int>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned short, float, float>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<unsigned short, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template void rows<short, int, short>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<short, int, int>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<short, float, float>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<short, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template void rows<int, int, int>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<int, float, float>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<int, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template void rows<float, float, float>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+    template void rows<float, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template void rows<double, double, double>(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    ///////////////////////////////////////////////////////////
+
+    template <int BLOCK_SIZE, typename T, typename S, typename D, int cn, class Op>
+    __global__ void colsKernel(const PtrStepSz<typename TypeVec<T, cn>::vec_type> src, typename TypeVec<D, cn>::vec_type* dst, const Op op)
+    {
+        typedef typename TypeVec<T, cn>::vec_type src_type;
+        typedef typename TypeVec<S, cn>::vec_type work_type;
+        typedef typename TypeVec<D, cn>::vec_type dst_type;
+
+        __shared__ S smem[BLOCK_SIZE * cn];
+
+        const int y = blockIdx.x;
+
+        const src_type* srcRow = src.ptr(y);
+
+        work_type myVal = op.template startValue<work_type>();
+
+        for (int x = threadIdx.x; x < src.cols; x += BLOCK_SIZE)
+            myVal = op(myVal, saturate_cast<work_type>(srcRow[x]));
+
+        device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(myVal), threadIdx.x, Unroll<cn>::op(op));
+
+        if (threadIdx.x == 0)
+            dst[y] = saturate_cast<dst_type>(op.result(myVal, src.cols));
+    }
+
+    template <typename T, typename S, typename D, int cn, class Op> void colsCaller(PtrStepSzb src, void* dst, cudaStream_t stream)
+    {
+        const int BLOCK_SIZE = 256;
+
+        const dim3 block(BLOCK_SIZE);
+        const dim3 grid(src.rows);
+
+        Op op;
+        colsKernel<BLOCK_SIZE, T, S, D, cn, Op><<<grid, block, 0, stream>>>((PtrStepSz<typename TypeVec<T, cn>::vec_type>) src, (typename TypeVec<D, cn>::vec_type*) dst, op);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+
+    }
+
+    template <typename T, typename S, typename D> void cols(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream)
+    {
+        typedef void (*func_t)(PtrStepSzb src, void* dst, cudaStream_t stream);
+        static const func_t funcs[5][4] =
+        {
+            {0,0,0,0},
+            {colsCaller<T, S, D, 1, Sum>, colsCaller<T, S, D, 1, Avg>, colsCaller<T, S, D, 1, Max>, colsCaller<T, S, D, 1, Min>},
+            {colsCaller<T, S, D, 2, Sum>, colsCaller<T, S, D, 2, Avg>, colsCaller<T, S, D, 2, Max>, colsCaller<T, S, D, 2, Min>},
+            {colsCaller<T, S, D, 3, Sum>, colsCaller<T, S, D, 3, Avg>, colsCaller<T, S, D, 3, Max>, colsCaller<T, S, D, 3, Min>},
+            {colsCaller<T, S, D, 4, Sum>, colsCaller<T, S, D, 4, Avg>, colsCaller<T, S, D, 4, Max>, colsCaller<T, S, D, 4, Min>},
+        };
+
+        funcs[cn][op](src, dst, stream);
+    }
+
+    template void cols<unsigned char, int, unsigned char>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned char, int, int>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned char, float, float>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned char, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+
+    template void cols<unsigned short, int, unsigned short>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned short, int, int>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned short, float, float>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<unsigned short, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+
+    template void cols<short, int, short>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<short, int, int>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<short, float, float>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<short, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+
+    template void cols<int, int, int>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<int, float, float>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<int, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+
+    template void cols<float, float, float>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+    template void cols<float, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+
+    template void cols<double, double, double>(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/matrix_reductions.cpp b/modules/gpu/src/matrix_reductions.cpp
index 0f1cf5ea8..9e6d9751f 100644
--- a/modules/gpu/src/matrix_reductions.cpp
+++ b/modules/gpu/src/matrix_reductions.cpp
@@ -204,34 +204,19 @@ double cv::gpu::norm(const GpuMat& src1, const GpuMat& src2, int normType)
 ////////////////////////////////////////////////////////////////////////
 // Sum
 
-namespace cv { namespace gpu { namespace device
+namespace sum
 {
-    namespace matrix_reductions
-    {
-        namespace sum
-        {
-            template <typename T>
-            void sumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
+    void getBufSize(int cols, int rows, int cn, int& bufcols, int& bufrows);
 
-            template <typename T>
-            void sumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
+    template <typename T, int cn>
+    void run(PtrStepSzb src, void* buf, double* sum);
 
-            template <typename T>
-            void absSumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
+    template <typename T, int cn>
+    void runAbs(PtrStepSzb src, void* buf, double* sum);
 
-            template <typename T>
-            void absSumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
-
-            template <typename T>
-            void sqrSumCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
-
-            template <typename T>
-            void sqrSumMultipassCaller(const PtrStepSzb src, PtrStepb buf, double* sum, int cn);
-
-            void getBufSizeRequired(int cols, int rows, int cn, int& bufcols, int& bufrows);
-        }
-    }
-}}}
+    template <typename T, int cn>
+    void runSqr(PtrStepSzb src, void* buf, double* sum);
+}
 
 Scalar cv::gpu::sum(const GpuMat& src)
 {
@@ -239,272 +224,165 @@ Scalar cv::gpu::sum(const GpuMat& src)
     return sum(src, buf);
 }
 
-
 Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf)
 {
-    using namespace cv::gpu::device::matrix_reductions::sum;
-
-    typedef void (*Caller)(const PtrStepSzb, PtrStepb, double*, int);
-
-    static Caller multipass_callers[] =
+    typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+    static const func_t funcs[7][5] =
     {
-        sumMultipassCaller<unsigned char>, sumMultipassCaller<char>,
-        sumMultipassCaller<unsigned short>, sumMultipassCaller<short>,
-        sumMultipassCaller<int>, sumMultipassCaller<float>
+        {0, ::sum::run<uchar , 1>, ::sum::run<uchar , 2>, ::sum::run<uchar , 3>, ::sum::run<uchar , 4>},
+        {0, ::sum::run<schar , 1>, ::sum::run<schar , 2>, ::sum::run<schar , 3>, ::sum::run<schar , 4>},
+        {0, ::sum::run<ushort, 1>, ::sum::run<ushort, 2>, ::sum::run<ushort, 3>, ::sum::run<ushort, 4>},
+        {0, ::sum::run<short , 1>, ::sum::run<short , 2>, ::sum::run<short , 3>, ::sum::run<short , 4>},
+        {0, ::sum::run<int   , 1>, ::sum::run<int   , 2>, ::sum::run<int   , 3>, ::sum::run<int   , 4>},
+        {0, ::sum::run<float , 1>, ::sum::run<float , 2>, ::sum::run<float , 3>, ::sum::run<float , 4>},
+        {0, ::sum::run<double, 1>, ::sum::run<double, 2>, ::sum::run<double, 3>, ::sum::run<double, 4>}
     };
 
-    static Caller singlepass_callers[] = {
-        sumCaller<unsigned char>, sumCaller<char>,
-        sumCaller<unsigned short>, sumCaller<short>,
-        sumCaller<int>, sumCaller<float>
-    };
-
-    CV_Assert(src.depth() <= CV_32F);
-
-    Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
-    ensureSizeIsEnough(buf_size, CV_8U, buf);
-
-    Caller* callers = multipass_callers;
-    if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-        callers = singlepass_callers;
-
-    Caller caller = callers[src.depth()];
-
-    double result[4];
-    caller(src, buf, result, src.channels());
-    return Scalar(result[0], result[1], result[2], result[3]);
-}
-
-
-Scalar cv::gpu::absSum(const GpuMat& src)
-{
-    GpuMat buf;
-    return absSum(src, buf);
-}
-
-
-Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf)
-{
-    using namespace cv::gpu::device::matrix_reductions::sum;
-
-    typedef void (*Caller)(const PtrStepSzb, PtrStepb, double*, int);
-
-    static Caller multipass_callers[] =
-    {
-        absSumMultipassCaller<unsigned char>, absSumMultipassCaller<char>,
-        absSumMultipassCaller<unsigned short>, absSumMultipassCaller<short>,
-        absSumMultipassCaller<int>, absSumMultipassCaller<float>
-    };
-
-    static Caller singlepass_callers[] =
-    {
-        absSumCaller<unsigned char>, absSumCaller<char>,
-        absSumCaller<unsigned short>, absSumCaller<short>,
-        absSumCaller<int>, absSumCaller<float>
-    };
-
-    CV_Assert(src.depth() <= CV_32F);
-
-    Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
-    ensureSizeIsEnough(buf_size, CV_8U, buf);
-
-    Caller* callers = multipass_callers;
-    if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-        callers = singlepass_callers;
-
-    Caller caller = callers[src.depth()];
-
-    double result[4];
-    caller(src, buf, result, src.channels());
-    return Scalar(result[0], result[1], result[2], result[3]);
-}
-
-
-Scalar cv::gpu::sqrSum(const GpuMat& src)
-{
-    GpuMat buf;
-    return sqrSum(src, buf);
-}
-
-
-Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf)
-{
-    using namespace cv::gpu::device::matrix_reductions::sum;
-
-    typedef void (*Caller)(const PtrStepSzb, PtrStepb, double*, int);
-
-    static Caller multipass_callers[] =
-    {
-        sqrSumMultipassCaller<unsigned char>, sqrSumMultipassCaller<char>,
-        sqrSumMultipassCaller<unsigned short>, sqrSumMultipassCaller<short>,
-        sqrSumMultipassCaller<int>, sqrSumMultipassCaller<float>
-    };
-
-    static Caller singlepass_callers[7] =
-    {
-        sqrSumCaller<unsigned char>, sqrSumCaller<char>,
-        sqrSumCaller<unsigned short>, sqrSumCaller<short>,
-        sqrSumCaller<int>, sqrSumCaller<float>
-    };
-
-    CV_Assert(src.depth() <= CV_32F);
-
-    Caller* callers = multipass_callers;
-    if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-        callers = singlepass_callers;
-
-    Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
-    ensureSizeIsEnough(buf_size, CV_8U, buf);
-
-    Caller caller = callers[src.depth()];
-
-    double result[4];
-    caller(src, buf, result, src.channels());
-    return Scalar(result[0], result[1], result[2], result[3]);
-}
-
-////////////////////////////////////////////////////////////////////////
-// Find min or max
-
-namespace cv { namespace gpu { namespace device
-{
-    namespace matrix_reductions
-    {
-        namespace minmax
-        {
-            void getBufSizeRequired(int cols, int rows, int elem_size, int& bufcols, int& bufrows);
-
-            template <typename T>
-            void minMaxCaller(const PtrStepSzb src, double* minval, double* maxval, PtrStepb buf);
-
-            template <typename T>
-            void minMaxMaskCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
-
-            template <typename T>
-            void minMaxMultipassCaller(const PtrStepSzb src, double* minval, double* maxval, PtrStepb buf);
-
-            template <typename T>
-            void minMaxMaskMultipassCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
-        }
-    }
-}}}
-
-
-void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask)
-{
-    GpuMat buf;
-    minMax(src, minVal, maxVal, mask, buf);
-}
-
-
-void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf)
-{
-    using namespace ::cv::gpu::device::matrix_reductions::minmax;
-
-    typedef void (*Caller)(const PtrStepSzb, double*, double*, PtrStepb);
-    typedef void (*MaskedCaller)(const PtrStepSzb, const PtrStepb, double*, double*, PtrStepb);
-
-    static Caller multipass_callers[] =
-    {
-        minMaxMultipassCaller<unsigned char>, minMaxMultipassCaller<char>,
-        minMaxMultipassCaller<unsigned short>, minMaxMultipassCaller<short>,
-        minMaxMultipassCaller<int>, minMaxMultipassCaller<float>, 0
-    };
-
-    static Caller singlepass_callers[] =
-    {
-        minMaxCaller<unsigned char>, minMaxCaller<char>,
-        minMaxCaller<unsigned short>, minMaxCaller<short>,
-        minMaxCaller<int>, minMaxCaller<float>, minMaxCaller<double>
-    };
-
-    static MaskedCaller masked_multipass_callers[] =
-    {
-        minMaxMaskMultipassCaller<unsigned char>, minMaxMaskMultipassCaller<char>,
-        minMaxMaskMultipassCaller<unsigned short>, minMaxMaskMultipassCaller<short>,
-        minMaxMaskMultipassCaller<int>, minMaxMaskMultipassCaller<float>, 0
-    };
-
-    static MaskedCaller masked_singlepass_callers[] =
-    {
-        minMaxMaskCaller<unsigned char>, minMaxMaskCaller<char>,
-        minMaxMaskCaller<unsigned short>, minMaxMaskCaller<short>,
-        minMaxMaskCaller<int>, minMaxMaskCaller<float>, minMaxMaskCaller<double>
-    };
-
-    CV_Assert(src.depth() <= CV_64F);
-    CV_Assert(src.channels() == 1);
-    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
-
     if (src.depth() == CV_64F)
     {
         if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    double minVal_; if (!minVal) minVal = &minVal_;
-    double maxVal_; if (!maxVal) maxVal = &maxVal_;
-
     Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, static_cast<int>(src.elemSize()), buf_size.width, buf_size.height);
+    ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
+    buf.setTo(Scalar::all(0));
 
-    if (mask.empty())
-    {
-        Caller* callers = multipass_callers;
-        if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-            callers = singlepass_callers;
+    const func_t func = funcs[src.depth()][src.channels()];
 
-        Caller caller = callers[src.type()];
-        CV_Assert(caller != 0);
-        caller(src, minVal, maxVal, buf);
-    }
-    else
-    {
-        MaskedCaller* callers = masked_multipass_callers;
-        if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-            callers = masked_singlepass_callers;
+    double result[4];
+    func(src, buf.data, result);
 
-        MaskedCaller caller = callers[src.type()];
-        CV_Assert(caller != 0);
-        caller(src, mask, minVal, maxVal, buf);
-    }
+    return Scalar(result[0], result[1], result[2], result[3]);
 }
 
+Scalar cv::gpu::absSum(const GpuMat& src)
+{
+    GpuMat buf;
+    return absSum(src, buf);
+}
+
+Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf)
+{
+    typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+    static const func_t funcs[7][5] =
+    {
+        {0, ::sum::runAbs<uchar , 1>, ::sum::runAbs<uchar , 2>, ::sum::runAbs<uchar , 3>, ::sum::runAbs<uchar , 4>},
+        {0, ::sum::runAbs<schar , 1>, ::sum::runAbs<schar , 2>, ::sum::runAbs<schar , 3>, ::sum::runAbs<schar , 4>},
+        {0, ::sum::runAbs<ushort, 1>, ::sum::runAbs<ushort, 2>, ::sum::runAbs<ushort, 3>, ::sum::runAbs<ushort, 4>},
+        {0, ::sum::runAbs<short , 1>, ::sum::runAbs<short , 2>, ::sum::runAbs<short , 3>, ::sum::runAbs<short , 4>},
+        {0, ::sum::runAbs<int   , 1>, ::sum::runAbs<int   , 2>, ::sum::runAbs<int   , 3>, ::sum::runAbs<int   , 4>},
+        {0, ::sum::runAbs<float , 1>, ::sum::runAbs<float , 2>, ::sum::runAbs<float , 3>, ::sum::runAbs<float , 4>},
+        {0, ::sum::runAbs<double, 1>, ::sum::runAbs<double, 2>, ::sum::runAbs<double, 3>, ::sum::runAbs<double, 4>}
+    };
+
+    Size buf_size;
+    ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
+    ensureSizeIsEnough(buf_size, CV_8U, buf);
+    buf.setTo(Scalar::all(0));
+
+    const func_t func = funcs[src.depth()][src.channels()];
+
+    double result[4];
+    func(src, buf.data, result);
+
+    return Scalar(result[0], result[1], result[2], result[3]);
+}
+
+Scalar cv::gpu::sqrSum(const GpuMat& src)
+{
+    GpuMat buf;
+    return sqrSum(src, buf);
+}
+
+Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf)
+{
+    typedef void (*func_t)(PtrStepSzb src, void* buf, double* sum);
+    static const func_t funcs[7][5] =
+    {
+        {0, ::sum::runSqr<uchar , 1>, ::sum::runSqr<uchar , 2>, ::sum::runSqr<uchar , 3>, ::sum::runSqr<uchar , 4>},
+        {0, ::sum::runSqr<schar , 1>, ::sum::runSqr<schar , 2>, ::sum::runSqr<schar , 3>, ::sum::runSqr<schar , 4>},
+        {0, ::sum::runSqr<ushort, 1>, ::sum::runSqr<ushort, 2>, ::sum::runSqr<ushort, 3>, ::sum::runSqr<ushort, 4>},
+        {0, ::sum::runSqr<short , 1>, ::sum::runSqr<short , 2>, ::sum::runSqr<short , 3>, ::sum::runSqr<short , 4>},
+        {0, ::sum::runSqr<int   , 1>, ::sum::runSqr<int   , 2>, ::sum::runSqr<int   , 3>, ::sum::runSqr<int   , 4>},
+        {0, ::sum::runSqr<float , 1>, ::sum::runSqr<float , 2>, ::sum::runSqr<float , 3>, ::sum::runSqr<float , 4>},
+        {0, ::sum::runSqr<double, 1>, ::sum::runSqr<double, 2>, ::sum::runSqr<double, 3>, ::sum::runSqr<double, 4>}
+    };
+
+    Size buf_size;
+    ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
+    ensureSizeIsEnough(buf_size, CV_8U, buf);
+    buf.setTo(Scalar::all(0));
+
+    const func_t func = funcs[src.depth()][src.channels()];
+
+    double result[4];
+    func(src, buf.data, result);
+
+    return Scalar(result[0], result[1], result[2], result[3]);
+}
 
 ////////////////////////////////////////////////////////////////////////
-// Locate min and max
+// minMax
 
-namespace cv { namespace gpu { namespace device
+namespace minMax
 {
-    namespace matrix_reductions
+    void getBufSize(int cols, int rows, int& bufcols, int& bufrows);
+
+    template <typename T>
+    void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+}
+
+void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask)
+{
+    GpuMat buf;
+    minMax(src, minVal, maxVal, mask, buf);
+}
+
+void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const GpuMat& mask, GpuMat& buf)
+{
+    typedef void (*func_t)(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, PtrStepb buf);
+    static const func_t funcs[] =
     {
-        namespace minmaxloc
-        {
-            void getBufSizeRequired(int cols, int rows, int elem_size, int& b1cols,
-                                    int& b1rows, int& b2cols, int& b2rows);
+        ::minMax::run<uchar>,
+        ::minMax::run<schar>,
+        ::minMax::run<ushort>,
+        ::minMax::run<short>,
+        ::minMax::run<int>,
+        ::minMax::run<float>,
+        ::minMax::run<double>
+    };
 
-            template <typename T>
-            void minMaxLocCaller(const PtrStepSzb src, double* minval, double* maxval,
-                                 int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
+    CV_Assert( src.channels() == 1 );
+    CV_Assert( mask.empty() || (mask.size() == src.size() && mask.type() == CV_8U) );
 
-            template <typename T>
-            void minMaxLocMaskCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval,
-                                     int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
-
-            template <typename T>
-            void minMaxLocMultipassCaller(const PtrStepSzb src, double* minval, double* maxval,
-                                          int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
-
-            template <typename T>
-            void minMaxLocMaskMultipassCaller(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval,
-                                              int minloc[2], int maxloc[2], PtrStepb valBuf, PtrStepb locBuf);
-        }
+    if (src.depth() == CV_64F)
+    {
+        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
-}}}
+
+    Size buf_size;
+    ::minMax::getBufSize(src.cols, src.rows, buf_size.width, buf_size.height);
+    ensureSizeIsEnough(buf_size, CV_8U, buf);
+
+    const func_t func = funcs[src.depth()];
+
+    double temp1, temp2;
+    func(src, mask, minVal ? minVal : &temp1, maxVal ? maxVal : &temp2, buf);
+}
+
+////////////////////////////////////////////////////////////////////////
+// minMaxLoc
+
+namespace minMaxLoc
+{
+    void getBufSize(int cols, int rows, size_t elem_size, int& b1cols, int& b1rows, int& b2cols, int& b2rows);
+
+    template <typename T>
+    void run(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+}
 
 void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask)
 {
@@ -515,42 +393,20 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
 void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc,
                         const GpuMat& mask, GpuMat& valBuf, GpuMat& locBuf)
 {
-    using namespace ::cv::gpu::device::matrix_reductions::minmaxloc;
-
-    typedef void (*Caller)(const PtrStepSzb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-    typedef void (*MaskedCaller)(const PtrStepSzb, const PtrStepb, double*, double*, int[2], int[2], PtrStepb, PtrStepb);
-
-    static Caller multipass_callers[] =
+    typedef void (*func_t)(const PtrStepSzb src, const PtrStepb mask, double* minval, double* maxval, int* minloc, int* maxloc, PtrStepb valbuf, PtrStep<unsigned int> locbuf);
+    static const func_t funcs[] =
     {
-        minMaxLocMultipassCaller<unsigned char>, minMaxLocMultipassCaller<char>,
-        minMaxLocMultipassCaller<unsigned short>, minMaxLocMultipassCaller<short>,
-        minMaxLocMultipassCaller<int>, minMaxLocMultipassCaller<float>, 0
+        ::minMaxLoc::run<uchar>,
+        ::minMaxLoc::run<schar>,
+        ::minMaxLoc::run<ushort>,
+        ::minMaxLoc::run<short>,
+        ::minMaxLoc::run<int>,
+        ::minMaxLoc::run<float>,
+        ::minMaxLoc::run<double>
     };
 
-    static Caller singlepass_callers[] =
-    {
-        minMaxLocCaller<unsigned char>, minMaxLocCaller<char>,
-        minMaxLocCaller<unsigned short>, minMaxLocCaller<short>,
-        minMaxLocCaller<int>, minMaxLocCaller<float>, minMaxLocCaller<double>
-    };
-
-    static MaskedCaller masked_multipass_callers[] =
-    {
-        minMaxLocMaskMultipassCaller<unsigned char>, minMaxLocMaskMultipassCaller<char>,
-        minMaxLocMaskMultipassCaller<unsigned short>, minMaxLocMaskMultipassCaller<short>,
-        minMaxLocMaskMultipassCaller<int>, minMaxLocMaskMultipassCaller<float>, 0
-    };
-
-    static MaskedCaller masked_singlepass_callers[] =
-    {
-        minMaxLocMaskCaller<unsigned char>, minMaxLocMaskCaller<char>,
-        minMaxLocMaskCaller<unsigned short>, minMaxLocMaskCaller<short>,
-        minMaxLocMaskCaller<int>, minMaxLocMaskCaller<float>, minMaxLocMaskCaller<double>
-    };
-
-    CV_Assert(src.depth() <= CV_64F);
-    CV_Assert(src.channels() == 1);
-    CV_Assert(mask.empty() || (mask.type() == CV_8U && src.size() == mask.size()));
+    CV_Assert( src.channels() == 1 );
+    CV_Assert( mask.empty() || (mask.size() == src.size() && mask.type() == CV_8U) );
 
     if (src.depth() == CV_64F)
     {
@@ -558,61 +414,28 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    double minVal_; if (!minVal) minVal = &minVal_;
-    double maxVal_; if (!maxVal) maxVal = &maxVal_;
-    int minLoc_[2];
-    int maxLoc_[2];
-
     Size valbuf_size, locbuf_size;
-    getBufSizeRequired(src.cols, src.rows, static_cast<int>(src.elemSize()), valbuf_size.width,
-                       valbuf_size.height, locbuf_size.width, locbuf_size.height);
+    ::minMaxLoc::getBufSize(src.cols, src.rows, src.elemSize(), valbuf_size.width, valbuf_size.height, locbuf_size.width, locbuf_size.height);
     ensureSizeIsEnough(valbuf_size, CV_8U, valBuf);
     ensureSizeIsEnough(locbuf_size, CV_8U, locBuf);
 
-    if (mask.empty())
-    {
-        Caller* callers = multipass_callers;
-        if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-            callers = singlepass_callers;
+    const func_t func = funcs[src.depth()];
 
-        Caller caller = callers[src.type()];
-        CV_Assert(caller != 0);
-        caller(src, minVal, maxVal, minLoc_, maxLoc_, valBuf, locBuf);
-    }
-    else
-    {
-        MaskedCaller* callers = masked_multipass_callers;
-        if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-            callers = masked_singlepass_callers;
-
-        MaskedCaller caller = callers[src.type()];
-        CV_Assert(caller != 0);
-        caller(src, mask, minVal, maxVal, minLoc_, maxLoc_, valBuf, locBuf);
-    }
-
-    if (minLoc) { minLoc->x = minLoc_[0]; minLoc->y = minLoc_[1]; }
-    if (maxLoc) { maxLoc->x = maxLoc_[0]; maxLoc->y = maxLoc_[1]; }
+    double temp1, temp2;
+    Point temp3, temp4;
+    func(src, mask, minVal ? minVal : &temp1, maxVal ? maxVal : &temp2, minLoc ? &minLoc->x : &temp3.x, maxLoc ? &maxLoc->x : &temp4.x, valBuf, locBuf);
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// Count non-zero elements
+// countNonZero
 
-namespace cv { namespace gpu { namespace device
+namespace countNonZero
 {
-    namespace matrix_reductions
-    {
-        namespace countnonzero
-        {
-            void getBufSizeRequired(int cols, int rows, int& bufcols, int& bufrows);
+    void getBufSize(int cols, int rows, int& bufcols, int& bufrows);
 
-            template <typename T>
-            int countNonZeroCaller(const PtrStepSzb src, PtrStepb buf);
-
-            template <typename T>
-            int countNonZeroMultipassCaller(const PtrStepSzb src, PtrStepb buf);
-        }
-    }
-}}}
+    template <typename T>
+    int run(const PtrStepSzb src, PtrStep<unsigned int> buf);
+}
 
 int cv::gpu::countNonZero(const GpuMat& src)
 {
@@ -620,27 +443,20 @@ int cv::gpu::countNonZero(const GpuMat& src)
     return countNonZero(src, buf);
 }
 
-
 int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
 {
-    using namespace ::cv::gpu::device::matrix_reductions::countnonzero;
-
-    typedef int (*Caller)(const PtrStepSzb src, PtrStepb buf);
-
-    static Caller multipass_callers[7] =
+    typedef int (*func_t)(const PtrStepSzb src, PtrStep<unsigned int> buf);
+    static const func_t funcs[] =
     {
-        countNonZeroMultipassCaller<unsigned char>, countNonZeroMultipassCaller<char>,
-        countNonZeroMultipassCaller<unsigned short>, countNonZeroMultipassCaller<short>,
-        countNonZeroMultipassCaller<int>, countNonZeroMultipassCaller<float>, 0
+        ::countNonZero::run<uchar>,
+        ::countNonZero::run<schar>,
+        ::countNonZero::run<ushort>,
+        ::countNonZero::run<short>,
+        ::countNonZero::run<int>,
+        ::countNonZero::run<float>,
+        ::countNonZero::run<double>
     };
 
-    static Caller singlepass_callers[7] =
-    {
-        countNonZeroCaller<unsigned char>, countNonZeroCaller<char>,
-        countNonZeroCaller<unsigned short>, countNonZeroCaller<short>,
-        countNonZeroCaller<int>, countNonZeroCaller<float>, countNonZeroCaller<double> };
-
-    CV_Assert(src.depth() <= CV_64F);
     CV_Assert(src.channels() == 1);
 
     if (src.depth() == CV_64F)
@@ -650,168 +466,190 @@ int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
     }
 
     Size buf_size;
-    getBufSizeRequired(src.cols, src.rows, buf_size.width, buf_size.height);
+    ::countNonZero::getBufSize(src.cols, src.rows, buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
 
-    Caller* callers = multipass_callers;
-    if (TargetArchs::builtWith(GLOBAL_ATOMICS) && DeviceInfo().supports(GLOBAL_ATOMICS))
-        callers = singlepass_callers;
+    const func_t func = funcs[src.depth()];
 
-    Caller caller = callers[src.type()];
-    CV_Assert(caller != 0);
-    return caller(src, buf);
+    return func(src, buf);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // reduce
 
-namespace cv { namespace gpu { namespace device
+namespace reduce
 {
-    namespace matrix_reductions
-    {
-        template <typename T, typename S, typename D> void reduceRows_gpu(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-        template <typename T, typename S, typename D> void reduceCols_gpu(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-    }
-}}}
+    template <typename T, typename S, typename D>
+    void rows(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+
+    template <typename T, typename S, typename D>
+    void cols(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+}
 
 void cv::gpu::reduce(const GpuMat& src, GpuMat& dst, int dim, int reduceOp, int dtype, Stream& stream)
 {
-    using namespace ::cv::gpu::device::matrix_reductions;
-
-    CV_Assert(src.depth() <= CV_32F && src.channels() <= 4 && dtype <= CV_32F);
-    CV_Assert(dim == 0 || dim == 1);
-    CV_Assert(reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG || reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN);
+    CV_Assert( src.channels() <= 4 );
+    CV_Assert( dim == 0 || dim == 1 );
+    CV_Assert( reduceOp == CV_REDUCE_SUM || reduceOp == CV_REDUCE_AVG || reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN );
 
     if (dtype < 0)
         dtype = src.depth();
 
-    dst.create(1, dim == 0 ? src.cols : src.rows, CV_MAKETYPE(dtype, src.channels()));
+    dst.create(1, dim == 0 ? src.cols : src.rows, CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
 
     if (dim == 0)
     {
-        typedef void (*caller_t)(const PtrStepSzb& src, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        static const caller_t callers[6][6] =
+        typedef void (*func_t)(PtrStepSzb src, void* dst, int op, cudaStream_t stream);
+        static const func_t funcs[7][7] =
         {
             {
-                reduceRows_gpu<unsigned char, int, unsigned char>,
-                0/*reduceRows_gpu<unsigned char, int, signed char>*/,
-                0/*reduceRows_gpu<unsigned char, int, unsigned short>*/,
-                0/*reduceRows_gpu<unsigned char, int, short>*/,
-                reduceRows_gpu<unsigned char, int, int>,
-                reduceRows_gpu<unsigned char, int, float>
+                ::reduce::rows<unsigned char, int, unsigned char>,
+                0/*::reduce::rows<unsigned char, int, signed char>*/,
+                0/*::reduce::rows<unsigned char, int, unsigned short>*/,
+                0/*::reduce::rows<unsigned char, int, short>*/,
+                ::reduce::rows<unsigned char, int, int>,
+                ::reduce::rows<unsigned char, float, float>,
+                ::reduce::rows<unsigned char, double, double>
             },
             {
-                0/*reduceRows_gpu<signed char, int, unsigned char>*/,
-                0/*reduceRows_gpu<signed char, int, signed char>*/,
-                0/*reduceRows_gpu<signed char, int, unsigned short>*/,
-                0/*reduceRows_gpu<signed char, int, short>*/,
-                0/*reduceRows_gpu<signed char, int, int>*/,
-                0/*reduceRows_gpu<signed char, int, float>*/
+                0/*::reduce::rows<signed char, int, unsigned char>*/,
+                0/*::reduce::rows<signed char, int, signed char>*/,
+                0/*::reduce::rows<signed char, int, unsigned short>*/,
+                0/*::reduce::rows<signed char, int, short>*/,
+                0/*::reduce::rows<signed char, int, int>*/,
+                0/*::reduce::rows<signed char, float, float>*/,
+                0/*::reduce::rows<signed char, double, double>*/
             },
             {
-                0/*reduceRows_gpu<unsigned short, int, unsigned char>*/,
-                0/*reduceRows_gpu<unsigned short, int, signed char>*/,
-                reduceRows_gpu<unsigned short, int, unsigned short>,
-                0/*reduceRows_gpu<unsigned short, int, short>*/,
-                reduceRows_gpu<unsigned short, int, int>,
-                reduceRows_gpu<unsigned short, int, float>
+                0/*::reduce::rows<unsigned short, int, unsigned char>*/,
+                0/*::reduce::rows<unsigned short, int, signed char>*/,
+                ::reduce::rows<unsigned short, int, unsigned short>,
+                0/*::reduce::rows<unsigned short, int, short>*/,
+                ::reduce::rows<unsigned short, int, int>,
+                ::reduce::rows<unsigned short, float, float>,
+                ::reduce::rows<unsigned short, double, double>
             },
             {
-                0/*reduceRows_gpu<short, int, unsigned char>*/,
-                0/*reduceRows_gpu<short, int, signed char>*/,
-                0/*reduceRows_gpu<short, int, unsigned short>*/,
-                reduceRows_gpu<short, int, short>,
-                reduceRows_gpu<short, int, int>,
-                reduceRows_gpu<short, int, float>
+                0/*::reduce::rows<short, int, unsigned char>*/,
+                0/*::reduce::rows<short, int, signed char>*/,
+                0/*::reduce::rows<short, int, unsigned short>*/,
+                ::reduce::rows<short, int, short>,
+                ::reduce::rows<short, int, int>,
+                ::reduce::rows<short, float, float>,
+                ::reduce::rows<short, double, double>
             },
             {
-                0/*reduceRows_gpu<int, int, unsigned char>*/,
-                0/*reduceRows_gpu<int, int, signed char>*/,
-                0/*reduceRows_gpu<int, int, unsigned short>*/,
-                0/*reduceRows_gpu<int, int, short>*/,
-                reduceRows_gpu<int, int, int>,
-                reduceRows_gpu<int, int, float>
+                0/*::reduce::rows<int, int, unsigned char>*/,
+                0/*::reduce::rows<int, int, signed char>*/,
+                0/*::reduce::rows<int, int, unsigned short>*/,
+                0/*::reduce::rows<int, int, short>*/,
+                ::reduce::rows<int, int, int>,
+                ::reduce::rows<int, float, float>,
+                ::reduce::rows<int, double, double>
             },
             {
-                0/*reduceRows_gpu<float, float, unsigned char>*/,
-                0/*reduceRows_gpu<float, float, signed char>*/,
-                0/*reduceRows_gpu<float, float, unsigned short>*/,
-                0/*reduceRows_gpu<float, float, short>*/,
-                0/*reduceRows_gpu<float, float, int>*/,
-                reduceRows_gpu<float, float, float>
+                0/*::reduce::rows<float, float, unsigned char>*/,
+                0/*::reduce::rows<float, float, signed char>*/,
+                0/*::reduce::rows<float, float, unsigned short>*/,
+                0/*::reduce::rows<float, float, short>*/,
+                0/*::reduce::rows<float, float, int>*/,
+                ::reduce::rows<float, float, float>,
+                ::reduce::rows<float, double, double>
+            },
+            {
+                0/*::reduce::rows<double, double, unsigned char>*/,
+                0/*::reduce::rows<double, double, signed char>*/,
+                0/*::reduce::rows<double, double, unsigned short>*/,
+                0/*::reduce::rows<double, double, short>*/,
+                0/*::reduce::rows<double, double, int>*/,
+                0/*::reduce::rows<double, double, float>*/,
+                ::reduce::rows<double, double, double>
             }
         };
 
-        const caller_t func = callers[src.depth()][dst.depth()];
+        const func_t func = funcs[src.depth()][dst.depth()];
 
         if (!func)
             CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of input and output array formats");
 
-        func(src.reshape(1), dst.reshape(1), reduceOp, StreamAccessor::getStream(stream));
+        func(src.reshape(1), dst.data, reduceOp, StreamAccessor::getStream(stream));
     }
     else
     {
-        typedef void (*caller_t)(const PtrStepSzb& src, int cn, const PtrStepSzb& dst, int reduceOp, cudaStream_t stream);
-
-        static const caller_t callers[6][6] =
+        typedef void (*func_t)(PtrStepSzb src, void* dst, int cn, int op, cudaStream_t stream);
+        static const func_t funcs[7][7] =
         {
             {
-                reduceCols_gpu<unsigned char, int, unsigned char>,
-                0/*reduceCols_gpu<unsigned char, int, signed char>*/,
-                0/*reduceCols_gpu<unsigned char, int, unsigned short>*/,
-                0/*reduceCols_gpu<unsigned char, int, short>*/,
-                reduceCols_gpu<unsigned char, int, int>,
-                reduceCols_gpu<unsigned char, int, float>
+                ::reduce::cols<unsigned char, int, unsigned char>,
+                0/*::reduce::cols<unsigned char, int, signed char>*/,
+                0/*::reduce::cols<unsigned char, int, unsigned short>*/,
+                0/*::reduce::cols<unsigned char, int, short>*/,
+                ::reduce::cols<unsigned char, int, int>,
+                ::reduce::cols<unsigned char, float, float>,
+                ::reduce::cols<unsigned char, double, double>
             },
             {
-                0/*reduceCols_gpu<signed char, int, unsigned char>*/,
-                0/*reduceCols_gpu<signed char, int, signed char>*/,
-                0/*reduceCols_gpu<signed char, int, unsigned short>*/,
-                0/*reduceCols_gpu<signed char, int, short>*/,
-                0/*reduceCols_gpu<signed char, int, int>*/,
-                0/*reduceCols_gpu<signed char, int, float>*/
+                0/*::reduce::cols<signed char, int, unsigned char>*/,
+                0/*::reduce::cols<signed char, int, signed char>*/,
+                0/*::reduce::cols<signed char, int, unsigned short>*/,
+                0/*::reduce::cols<signed char, int, short>*/,
+                0/*::reduce::cols<signed char, int, int>*/,
+                0/*::reduce::cols<signed char, float, float>*/,
+                0/*::reduce::cols<signed char, double, double>*/
             },
             {
-                0/*reduceCols_gpu<unsigned short, int, unsigned char>*/,
-                0/*reduceCols_gpu<unsigned short, int, signed char>*/,
-                reduceCols_gpu<unsigned short, int, unsigned short>,
-                0/*reduceCols_gpu<unsigned short, int, short>*/,
-                reduceCols_gpu<unsigned short, int, int>,
-                reduceCols_gpu<unsigned short, int, float>
+                0/*::reduce::cols<unsigned short, int, unsigned char>*/,
+                0/*::reduce::cols<unsigned short, int, signed char>*/,
+                ::reduce::cols<unsigned short, int, unsigned short>,
+                0/*::reduce::cols<unsigned short, int, short>*/,
+                ::reduce::cols<unsigned short, int, int>,
+                ::reduce::cols<unsigned short, float, float>,
+                ::reduce::cols<unsigned short, double, double>
             },
             {
-                0/*reduceCols_gpu<short, int, unsigned char>*/,
-                0/*reduceCols_gpu<short, int, signed char>*/,
-                0/*reduceCols_gpu<short, int, unsigned short>*/,
-                reduceCols_gpu<short, int, short>,
-                reduceCols_gpu<short, int, int>,
-                reduceCols_gpu<short, int, float>
+                0/*::reduce::cols<short, int, unsigned char>*/,
+                0/*::reduce::cols<short, int, signed char>*/,
+                0/*::reduce::cols<short, int, unsigned short>*/,
+                ::reduce::cols<short, int, short>,
+                ::reduce::cols<short, int, int>,
+                ::reduce::cols<short, float, float>,
+                ::reduce::cols<short, double, double>
             },
             {
-                0/*reduceCols_gpu<int, int, unsigned char>*/,
-                0/*reduceCols_gpu<int, int, signed char>*/,
-                0/*reduceCols_gpu<int, int, unsigned short>*/,
-                0/*reduceCols_gpu<int, int, short>*/,
-                reduceCols_gpu<int, int, int>,
-                reduceCols_gpu<int, int, float>
+                0/*::reduce::cols<int, int, unsigned char>*/,
+                0/*::reduce::cols<int, int, signed char>*/,
+                0/*::reduce::cols<int, int, unsigned short>*/,
+                0/*::reduce::cols<int, int, short>*/,
+                ::reduce::cols<int, int, int>,
+                ::reduce::cols<int, float, float>,
+                ::reduce::cols<int, double, double>
             },
             {
-                0/*reduceCols_gpu<float, unsigned char>*/,
-                0/*reduceCols_gpu<float, signed char>*/,
-                0/*reduceCols_gpu<float, unsigned short>*/,
-                0/*reduceCols_gpu<float, short>*/,
-                0/*reduceCols_gpu<float, int>*/,
-                reduceCols_gpu<float, float, float>
+                0/*::reduce::cols<float, float, unsigned char>*/,
+                0/*::reduce::cols<float, float, signed char>*/,
+                0/*::reduce::cols<float, float, unsigned short>*/,
+                0/*::reduce::cols<float, float, short>*/,
+                0/*::reduce::cols<float, float, int>*/,
+                ::reduce::cols<float, float, float>,
+                ::reduce::cols<float, double, double>
+            },
+            {
+                0/*::reduce::cols<double, double, unsigned char>*/,
+                0/*::reduce::cols<double, double, signed char>*/,
+                0/*::reduce::cols<double, double, unsigned short>*/,
+                0/*::reduce::cols<double, double, short>*/,
+                0/*::reduce::cols<double, double, int>*/,
+                0/*::reduce::cols<double, double, float>*/,
+                ::reduce::cols<double, double, double>
             }
         };
 
-        const caller_t func = callers[src.depth()][dst.depth()];
+        const func_t func = funcs[src.depth()][dst.depth()];
 
         if (!func)
             CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of input and output array formats");
 
-        func(src, src.channels(), dst, reduceOp, StreamAccessor::getStream(stream));
+        func(src, dst.data, src.channels(), reduceOp, StreamAccessor::getStream(stream));
     }
 }
 
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index 13bc2d2f4..abdcb0fa7 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -2982,7 +2982,7 @@ TEST_P(Sum, Sqr)
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
-    TYPES(CV_8U, CV_32F, 1, 4),
+    TYPES(CV_8U, CV_64F, 1, 4),
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3351,7 +3351,14 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
         cv::gpu::setDevice(devInfo.deviceID());
 
         type = CV_MAKE_TYPE(depth, channels);
-        dst_depth = (reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN) ? depth : CV_32F;
+
+        if (reduceOp == CV_REDUCE_MAX || reduceOp == CV_REDUCE_MIN)
+            dst_depth = depth;
+        else if (reduceOp == CV_REDUCE_SUM)
+            dst_depth = depth == CV_8U ? CV_32S : depth < CV_64F ? CV_32F : depth;
+        else
+            dst_depth = depth < CV_32F ? CV_32F : depth;
+
         dst_type = CV_MAKE_TYPE(dst_depth, channels);
     }
 
@@ -3392,7 +3399,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
     testing::Values(MatDepth(CV_8U),
                     MatDepth(CV_16U),
                     MatDepth(CV_16S),
-                    MatDepth(CV_32F)),
+                    MatDepth(CV_32F),
+                    MatDepth(CV_64F)),
     ALL_CHANNELS,
     ALL_REDUCE_CODES,
     WHOLE_SUBMAT));

From e6b1ccdcdfeb21c4f6ab0d522746f6ba8e6f5362 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 12 Nov 2012 14:22:31 +0400
Subject: [PATCH 090/155] removed old reduce implementation

---
 .../gpu/device/detail/reduction_detail.hpp    | 841 ------------------
 .../include/opencv2/gpu/device/utility.hpp    |  24 -
 2 files changed, 865 deletions(-)
 delete mode 100644 modules/gpu/include/opencv2/gpu/device/detail/reduction_detail.hpp

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduction_detail.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduction_detail.hpp
deleted file mode 100644
index 0274f204a..000000000
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduction_detail.hpp
+++ /dev/null
@@ -1,841 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
-// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the Intel Corporation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef __OPENCV_GPU_REDUCTION_DETAIL_HPP__
-#define __OPENCV_GPU_REDUCTION_DETAIL_HPP__
-
-namespace cv { namespace gpu { namespace device
-{
-    namespace utility_detail
-    {
-        ///////////////////////////////////////////////////////////////////////////////
-        // Reductor
-
-        template <int n> struct WarpReductor
-        {
-            template <typename T, typename Op> static __device__ __forceinline__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                if (tid < n)
-                    data[tid] = partial_reduction;
-                if (n > 32) __syncthreads();
-
-                if (n > 32)
-                {
-                    if (tid < n - 32)
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid + 32]);
-                    if (tid < 16)
-                    {
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                    }
-                }
-                else if (n > 16)
-                {
-                    if (tid < n - 16)
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
-                    if (tid < 8)
-                    {
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                    }
-                }
-                else if (n > 8)
-                {
-                    if (tid < n - 8)
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
-                    if (tid < 4)
-                    {
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                    }
-                }
-                else if (n > 4)
-                {
-                    if (tid < n - 4)
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
-                    if (tid < 2)
-                    {
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                    }
-                }
-                else if (n > 2)
-                {
-                    if (tid < n - 2)
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                    if (tid < 2)
-                    {
-                        data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                    }
-                }
-            }
-        };
-        template <> struct WarpReductor<64>
-        {
-            template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                data[tid] = partial_reduction;
-                __syncthreads();
-
-                if (tid < 32)
-                {
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 32]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 8 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 4 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 2 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 1 ]);
-                }
-            }
-        };
-        template <> struct WarpReductor<32>
-        {
-            template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                data[tid] = partial_reduction;
-
-                if (tid < 16)
-                {
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 8 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 4 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 2 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 1 ]);
-                }
-            }
-        };
-        template <> struct WarpReductor<16>
-        {
-            template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                data[tid] = partial_reduction;
-
-                if (tid < 8)
-                {
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 8 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 4 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 2 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 1 ]);
-                }
-            }
-        };
-        template <> struct WarpReductor<8>
-        {
-            template <typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                data[tid] = partial_reduction;
-
-                if (tid < 4)
-                {
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 4 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 2 ]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 1 ]);
-                }
-            }
-        };
-
-        template <bool warp> struct ReductionDispatcher;
-        template <> struct ReductionDispatcher<true>
-        {
-            template <int n, typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                WarpReductor<n>::reduce(data, partial_reduction, tid, op);
-            }
-        };
-        template <> struct ReductionDispatcher<false>
-        {
-            template <int n, typename T, typename Op> static __device__ void reduce(volatile T* data, T& partial_reduction, int tid, const Op& op)
-            {
-                if (tid < n)
-                    data[tid] = partial_reduction;
-                __syncthreads();
-
-
-                if (n == 512) { if (tid < 256) { data[tid] = partial_reduction = op(partial_reduction, data[tid + 256]); } __syncthreads(); }
-                if (n >= 256) { if (tid < 128) { data[tid] = partial_reduction = op(partial_reduction, data[tid + 128]); } __syncthreads(); }
-                if (n >= 128) { if (tid <  64) { data[tid] = partial_reduction = op(partial_reduction, data[tid +  64]); } __syncthreads(); }
-
-                if (tid < 32)
-                {
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 32]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid + 16]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  8]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  4]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  2]);
-                    data[tid] = partial_reduction = op(partial_reduction, data[tid +  1]);
-                }
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // PredValWarpReductor
-
-        template <int n> struct PredValWarpReductor;
-        template <> struct PredValWarpReductor<64>
-        {
-            template <typename T, typename V, typename Pred>
-            static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                if (tid < 32)
-                {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
-
-                    T reg = sdata[tid + 32];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 32];
-                    }
-
-                    reg = sdata[tid + 16];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 16];
-                    }
-
-                    reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 1];
-                    }
-                }
-            }
-        };
-        template <> struct PredValWarpReductor<32>
-        {
-            template <typename T, typename V, typename Pred>
-            static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                if (tid < 16)
-                {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
-
-                    T reg = sdata[tid + 16];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 16];
-                    }
-
-                    reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 1];
-                    }
-                }
-            }
-        };
-
-        template <> struct PredValWarpReductor<16>
-        {
-            template <typename T, typename V, typename Pred>
-            static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                if (tid < 8)
-                {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
-
-                    T reg = reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 1];
-                    }
-                }
-            }
-        };
-        template <> struct PredValWarpReductor<8>
-        {
-            template <typename T, typename V, typename Pred>
-            static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                if (tid < 4)
-                {
-                    myData = sdata[tid];
-                    myVal = sval[tid];
-
-                    T reg = reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 1];
-                    }
-                }
-            }
-        };
-
-        template <bool warp> struct PredValReductionDispatcher;
-        template <> struct PredValReductionDispatcher<true>
-        {
-            template <int n, typename T, typename V, typename Pred> static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                PredValWarpReductor<n>::reduce(myData, myVal, sdata, sval, tid, pred);
-            }
-        };
-        template <> struct PredValReductionDispatcher<false>
-        {
-            template <int n, typename T, typename V, typename Pred> static __device__ void reduce(T& myData, V& myVal, volatile T* sdata, V* sval, int tid, const Pred& pred)
-            {
-                myData = sdata[tid];
-                myVal = sval[tid];
-
-                if (n >= 512 && tid < 256)
-                {
-                    T reg = sdata[tid + 256];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 256];
-                    }
-                    __syncthreads();
-                }
-                if (n >= 256 && tid < 128)
-                {
-                    T reg = sdata[tid + 128];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 128];
-                    }
-                    __syncthreads();
-                }
-                if (n >= 128 && tid < 64)
-                {
-                    T reg = sdata[tid + 64];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval[tid] = myVal = sval[tid + 64];
-                    }
-                    __syncthreads();
-                }
-
-                if (tid < 32)
-                {
-                    if (n >= 64)
-                    {
-                        T reg = sdata[tid + 32];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 32];
-                        }
-                    }
-                    if (n >= 32)
-                    {
-                        T reg = sdata[tid + 16];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 16];
-                        }
-                    }
-                    if (n >= 16)
-                    {
-                        T reg = sdata[tid + 8];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 8];
-                        }
-                    }
-                    if (n >= 8)
-                    {
-                        T reg = sdata[tid + 4];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 4];
-                        }
-                    }
-                    if (n >= 4)
-                    {
-                        T reg = sdata[tid + 2];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 2];
-                        }
-                    }
-                    if (n >= 2)
-                    {
-                        T reg = sdata[tid + 1];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval[tid] = myVal = sval[tid + 1];
-                        }
-                    }
-                }
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////////////
-        // PredVal2WarpReductor
-
-        template <int n> struct PredVal2WarpReductor;
-        template <> struct PredVal2WarpReductor<64>
-        {
-            template <typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                if (tid < 32)
-                {
-                    myData = sdata[tid];
-                    myVal1 = sval1[tid];
-                    myVal2 = sval2[tid];
-
-                    T reg = sdata[tid + 32];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 32];
-                        sval2[tid] = myVal2 = sval2[tid + 32];
-                    }
-
-                    reg = sdata[tid + 16];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 16];
-                        sval2[tid] = myVal2 = sval2[tid + 16];
-                    }
-
-                    reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 8];
-                        sval2[tid] = myVal2 = sval2[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 4];
-                        sval2[tid] = myVal2 = sval2[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 2];
-                        sval2[tid] = myVal2 = sval2[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 1];
-                        sval2[tid] = myVal2 = sval2[tid + 1];
-                    }
-                }
-            }
-        };
-        template <> struct PredVal2WarpReductor<32>
-        {
-            template <typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                if (tid < 16)
-                {
-                    myData = sdata[tid];
-                    myVal1 = sval1[tid];
-                    myVal2 = sval2[tid];
-
-                    T reg = sdata[tid + 16];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 16];
-                        sval2[tid] = myVal2 = sval2[tid + 16];
-                    }
-
-                    reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 8];
-                        sval2[tid] = myVal2 = sval2[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 4];
-                        sval2[tid] = myVal2 = sval2[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 2];
-                        sval2[tid] = myVal2 = sval2[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 1];
-                        sval2[tid] = myVal2 = sval2[tid + 1];
-                    }
-                }
-            }
-        };
-
-        template <> struct PredVal2WarpReductor<16>
-        {
-            template <typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                if (tid < 8)
-                {
-                    myData = sdata[tid];
-                    myVal1 = sval1[tid];
-                    myVal2 = sval2[tid];
-
-                    T reg = reg = sdata[tid + 8];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 8];
-                        sval2[tid] = myVal2 = sval2[tid + 8];
-                    }
-
-                    reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 4];
-                        sval2[tid] = myVal2 = sval2[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 2];
-                        sval2[tid] = myVal2 = sval2[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 1];
-                        sval2[tid] = myVal2 = sval2[tid + 1];
-                    }
-                }
-            }
-        };
-        template <> struct PredVal2WarpReductor<8>
-        {
-            template <typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                if (tid < 4)
-                {
-                    myData = sdata[tid];
-                    myVal1 = sval1[tid];
-                    myVal2 = sval2[tid];
-
-                    T reg = reg = sdata[tid + 4];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 4];
-                        sval2[tid] = myVal2 = sval2[tid + 4];
-                    }
-
-                    reg = sdata[tid + 2];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 2];
-                        sval2[tid] = myVal2 = sval2[tid + 2];
-                    }
-
-                    reg = sdata[tid + 1];
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 1];
-                        sval2[tid] = myVal2 = sval2[tid + 1];
-                    }
-                }
-            }
-        };
-
-        template <bool warp> struct PredVal2ReductionDispatcher;
-        template <> struct PredVal2ReductionDispatcher<true>
-        {
-            template <int n, typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                PredVal2WarpReductor<n>::reduce(myData, myVal1, myVal2, sdata, sval1, sval2, tid, pred);
-            }
-        };
-        template <> struct PredVal2ReductionDispatcher<false>
-        {
-            template <int n, typename T, typename V1, typename V2, typename Pred>
-            static __device__ void reduce(T& myData, V1& myVal1, V2& myVal2, volatile T* sdata, V1* sval1, V2* sval2, int tid, const Pred& pred)
-            {
-                myData = sdata[tid];
-                myVal1 = sval1[tid];
-                myVal2 = sval2[tid];
-
-                if (n >= 512 && tid < 256)
-                {
-                    T reg = sdata[tid + 256];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 256];
-                        sval2[tid] = myVal2 = sval2[tid + 256];
-                    }
-                    __syncthreads();
-                }
-                if (n >= 256 && tid < 128)
-                {
-                    T reg = sdata[tid + 128];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 128];
-                        sval2[tid] = myVal2 = sval2[tid + 128];
-                    }
-                    __syncthreads();
-                }
-                if (n >= 128 && tid < 64)
-                {
-                    T reg = sdata[tid + 64];
-
-                    if (pred(reg, myData))
-                    {
-                        sdata[tid] = myData = reg;
-                        sval1[tid] = myVal1 = sval1[tid + 64];
-                        sval2[tid] = myVal2 = sval2[tid + 64];
-                    }
-                    __syncthreads();
-                }
-
-                if (tid < 32)
-                {
-                    if (n >= 64)
-                    {
-                        T reg = sdata[tid + 32];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 32];
-                            sval2[tid] = myVal2 = sval2[tid + 32];
-                        }
-                    }
-                    if (n >= 32)
-                    {
-                        T reg = sdata[tid + 16];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 16];
-                            sval2[tid] = myVal2 = sval2[tid + 16];
-                        }
-                    }
-                    if (n >= 16)
-                    {
-                        T reg = sdata[tid + 8];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 8];
-                            sval2[tid] = myVal2 = sval2[tid + 8];
-                        }
-                    }
-                    if (n >= 8)
-                    {
-                        T reg = sdata[tid + 4];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 4];
-                            sval2[tid] = myVal2 = sval2[tid + 4];
-                        }
-                    }
-                    if (n >= 4)
-                    {
-                        T reg = sdata[tid + 2];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 2];
-                            sval2[tid] = myVal2 = sval2[tid + 2];
-                        }
-                    }
-                    if (n >= 2)
-                    {
-                        T reg = sdata[tid + 1];
-
-                        if (pred(reg, myData))
-                        {
-                            sdata[tid] = myData = reg;
-                            sval1[tid] = myVal1 = sval1[tid + 1];
-                            sval2[tid] = myVal2 = sval2[tid + 1];
-                        }
-                    }
-                }
-            }
-        };
-    } // namespace utility_detail
-}}} // namespace cv { namespace gpu { namespace device
-
-#endif // __OPENCV_GPU_REDUCTION_DETAIL_HPP__
diff --git a/modules/gpu/include/opencv2/gpu/device/utility.hpp b/modules/gpu/include/opencv2/gpu/device/utility.hpp
index e44d51a6a..dd2dd8af0 100644
--- a/modules/gpu/include/opencv2/gpu/device/utility.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/utility.hpp
@@ -45,7 +45,6 @@
 
 #include "saturate_cast.hpp"
 #include "datamov_utils.hpp"
-#include "detail/reduction_detail.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -156,29 +155,6 @@ namespace cv { namespace gpu { namespace device
         }
     };
 
-    ///////////////////////////////////////////////////////////////////////////////
-    // Reduction
-
-    template <int n, typename T, typename Op> __device__ __forceinline__ void reduce_old(volatile T* data, T& partial_reduction, int tid, const Op& op)
-    {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        utility_detail::ReductionDispatcher<n <= 64>::reduce<n>(data, partial_reduction, tid, op);
-    }
-
-    template <int n, typename T, typename V, typename Pred>
-    __device__ __forceinline__ void reducePredVal(volatile T* sdata, T& myData, V* sval, V& myVal, int tid, const Pred& pred)
-    {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        utility_detail::PredValReductionDispatcher<n <= 64>::reduce<n>(myData, myVal, sdata, sval, tid, pred);
-    }
-
-    template <int n, typename T, typename V1, typename V2, typename Pred>
-    __device__ __forceinline__ void reducePredVal2(volatile T* sdata, T& myData, V1* sval1, V1& myVal1, V2* sval2, V2& myVal2, int tid, const Pred& pred)
-    {
-        StaticAssert<n >= 8 && n <= 512>::check();
-        utility_detail::PredVal2ReductionDispatcher<n <= 64>::reduce<n>(myData, myVal1, myVal2, sdata, sval1, sval2, tid, pred);
-    }
-
     ///////////////////////////////////////////////////////////////////////////////
     // Solve linear system
 

From 76e8794e81188a640bcc366527d6a2da1cffe072 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 15 Nov 2012 12:00:38 +0400
Subject: [PATCH 091/155] fixed warnings on old compute capabilities

---
 modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp    | 6 ++++++
 .../include/opencv2/gpu/device/detail/reduce_key_val.hpp    | 6 ++++++
 modules/gpu/src/cuda/surf.cu                                | 2 ++
 3 files changed, 14 insertions(+)

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
index 628129ea3..2b2ba6773 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
@@ -260,7 +260,9 @@ namespace cv { namespace gpu { namespace device
 
                 if (tid < N / 2)
                 {
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (unsigned int i = N / 2; i >= 1; i /= 2)
                         merge(smem, val, tid, i, op);
                 }
@@ -289,7 +291,9 @@ namespace cv { namespace gpu { namespace device
 
                 if (laneId < 16)
                 {
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (int i = 16; i >= 1; i /= 2)
                         merge(smem, val, tid, i, op);
                 }
@@ -311,7 +315,9 @@ namespace cv { namespace gpu { namespace device
                     for (int i = M / 2; i >= 1; i /= 2)
                         mergeShfl(val, i, M, op);
                 #else
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (int i = M / 2; i >= 1; i /= 2)
                         merge(smem, val, tid, i, op);
                 #endif
diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
index f7531da24..f1aa285d3 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
@@ -388,7 +388,9 @@ namespace cv { namespace gpu { namespace device
 
                 if (tid < N / 2)
                 {
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (unsigned int i = N / 2; i >= 1; i /= 2)
                         merge(skeys, key, svals, val, cmp, tid, i);
                 }
@@ -421,7 +423,9 @@ namespace cv { namespace gpu { namespace device
 
                 if (laneId < 16)
                 {
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (int i = 16; i >= 1; i /= 2)
                         merge(skeys, key, svals, val, cmp, tid, i);
                 }
@@ -448,7 +452,9 @@ namespace cv { namespace gpu { namespace device
                     for (unsigned int i = M / 2; i >= 1; i /= 2)
                         mergeShfl(key, val, cml, i, M);
                 #else
+                #if __CUDA_ARCH__ >= 200
                     #pragma unroll
+                #endif
                     for (unsigned int i = M / 2; i >= 1; i /= 2)
                         merge(skeys, key, svals, val, cmp, tid, i);
                 #endif
diff --git a/modules/gpu/src/cuda/surf.cu b/modules/gpu/src/cuda/surf.cu
index c12192555..73fcbc3d1 100644
--- a/modules/gpu/src/cuda/surf.cu
+++ b/modules/gpu/src/cuda/surf.cu
@@ -568,7 +568,9 @@ namespace cv { namespace gpu { namespace device
 
             float bestx = 0, besty = 0, best_mod = 0;
 
+        #if __CUDA_ARCH__ >= 200
             #pragma unroll
+        #endif
             for (int i = 0; i < 18; ++i)
             {
                 const int dir = (i * 4 + threadIdx.y) * ORI_SEARCH_INC;

From 572d2d6a84540595d53e43831e7039e7ac07491d Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 16 Nov 2012 12:49:43 +0400
Subject: [PATCH 092/155] warpScanInclusive

---
 .../opencv2/gpu/device/warp_shuffle.hpp       | 48 +++++++++++++++++++
 .../gpu/src/nvidia/NCVHaarObjectDetection.cu  | 19 +++++++-
 .../gpu/src/nvidia/NPP_staging/NPP_staging.cu | 34 ++++++++++++-
 3 files changed, 99 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp b/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp
index 39b7e852a..8b4479a79 100644
--- a/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/warp_shuffle.hpp
@@ -54,6 +54,14 @@ namespace cv { namespace gpu { namespace device
         return T();
     #endif
     }
+    __device__ __forceinline__ unsigned int shfl(unsigned int val, int srcLane, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return (unsigned int) __shfl((int) val, srcLane, width);
+    #else
+        return 0;
+    #endif
+    }
     __device__ __forceinline__ double shfl(double val, int srcLane, int width = warpSize)
     {
     #if __CUDA_ARCH__ >= 300
@@ -78,6 +86,14 @@ namespace cv { namespace gpu { namespace device
         return T();
     #endif
     }
+    __device__ __forceinline__ unsigned int shfl_down(unsigned int val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return (unsigned int) __shfl_down((int) val, delta, width);
+    #else
+        return 0;
+    #endif
+    }
     __device__ __forceinline__ double shfl_down(double val, unsigned int delta, int width = warpSize)
     {
     #if __CUDA_ARCH__ >= 300
@@ -92,6 +108,38 @@ namespace cv { namespace gpu { namespace device
         return 0.0;
     #endif
     }
+
+    template <typename T>
+    __device__ __forceinline__ T shfl_up(T val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return __shfl_up(val, delta, width);
+    #else
+        return T();
+    #endif
+    }
+    __device__ __forceinline__ unsigned int shfl_up(unsigned int val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        return (unsigned int) __shfl_up((int) val, delta, width);
+    #else
+        return 0;
+    #endif
+    }
+    __device__ __forceinline__ double shfl_up(double val, unsigned int delta, int width = warpSize)
+    {
+    #if __CUDA_ARCH__ >= 300
+        int lo = __double2loint(val);
+        int hi = __double2hiint(val);
+
+        lo = __shfl_up(lo, delta, width);
+        hi = __shfl_up(hi, delta, width);
+
+        return __hiloint2double(hi, lo);
+    #else
+        return 0.0;
+    #endif
+    }
 }}}
 
 #endif // __OPENCV_GPU_WARP_SHUFFLE_HPP__
diff --git a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
index 2a8f41959..fb057ae79 100644
--- a/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
+++ b/modules/gpu/src/nvidia/NCVHaarObjectDetection.cu
@@ -65,6 +65,8 @@
 #include "NPP_staging/NPP_staging.hpp"
 #include "NCVRuntimeTemplates.hpp"
 #include "NCVHaarObjectDetection.hpp"
+#include "opencv2/gpu/device/warp.hpp"
+#include "opencv2/gpu/device/warp_shuffle.hpp"
 
 
 //==============================================================================
@@ -81,6 +83,20 @@ NCV_CT_ASSERT(K_WARP_SIZE == 32); //this is required for the manual unroll of th
 //assuming size <= WARP_SIZE and size is power of 2
 __device__ Ncv32u warpScanInclusive(Ncv32u idata, volatile Ncv32u *s_Data)
 {
+#if __CUDA_ARCH__ >= 300
+    const unsigned int laneId = cv::gpu::device::Warp::laneId();
+
+    // scan on shuffl functions
+    #pragma unroll
+    for (int i = 1; i <= (K_WARP_SIZE / 2); i *= 2)
+    {
+        const Ncv32u n = cv::gpu::device::shfl_up(idata, i);
+        if (laneId >= i)
+              idata += n;
+    }
+
+    return idata;
+#else
     Ncv32u pos = 2 * threadIdx.x - (threadIdx.x & (K_WARP_SIZE - 1));
     s_Data[pos] = 0;
     pos += K_WARP_SIZE;
@@ -93,6 +109,7 @@ __device__ Ncv32u warpScanInclusive(Ncv32u idata, volatile Ncv32u *s_Data)
     s_Data[pos] += s_Data[pos - 16];
 
     return s_Data[pos];
+#endif
 }
 
 __device__ __forceinline__ Ncv32u warpScanExclusive(Ncv32u idata, volatile Ncv32u *s_Data)
@@ -2317,4 +2334,4 @@ NCVStatus ncvHaarStoreNVBIN_host(const std::string &filename,
     return NCV_SUCCESS;
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
index a3a1075fd..f4ec9aace 100644
--- a/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
+++ b/modules/gpu/src/nvidia/NPP_staging/NPP_staging.cu
@@ -44,6 +44,8 @@
 #include <vector>
 #include <cuda_runtime.h>
 #include "NPP_staging.hpp"
+#include "opencv2/gpu/device/warp.hpp"
+#include "opencv2/gpu/device/warp_shuffle.hpp"
 
 
 texture<Ncv8u,  1, cudaReadModeElementType> tex8u;
@@ -90,6 +92,36 @@ NCV_CT_ASSERT(K_WARP_SIZE == 32); //this is required for the manual unroll of th
 //assuming size <= WARP_SIZE and size is power of 2
 template <class T>
 inline __device__ T warpScanInclusive(T idata, volatile T *s_Data)
+{
+#if __CUDA_ARCH__ >= 300
+    const unsigned int laneId = cv::gpu::device::Warp::laneId();
+
+    // scan on shuffl functions
+    #pragma unroll
+    for (int i = 1; i <= (K_WARP_SIZE / 2); i *= 2)
+    {
+        const T n = cv::gpu::device::shfl_up(idata, i);
+        if (laneId >= i)
+              idata += n;
+    }
+
+    return idata;
+#else
+    Ncv32u pos = 2 * threadIdx.x - (threadIdx.x & (K_WARP_SIZE - 1));
+    s_Data[pos] = 0;
+    pos += K_WARP_SIZE;
+    s_Data[pos] = idata;
+
+    s_Data[pos] += s_Data[pos - 1];
+    s_Data[pos] += s_Data[pos - 2];
+    s_Data[pos] += s_Data[pos - 4];
+    s_Data[pos] += s_Data[pos - 8];
+    s_Data[pos] += s_Data[pos - 16];
+
+    return s_Data[pos];
+#endif
+}
+inline __device__ Ncv64u warpScanInclusive(Ncv64u idata, volatile Ncv64u *s_Data)
 {
     Ncv32u pos = 2 * threadIdx.x - (threadIdx.x & (K_WARP_SIZE - 1));
     s_Data[pos] = 0;
@@ -2578,4 +2610,4 @@ NCVStatus nppiStResize_32f_C1R(const Ncv32f *pSrc,
     return status;
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From a71ef7d67b8d463bd6bbd476fe64b8938d0fe9a3 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 16 Nov 2012 14:48:09 +0400
Subject: [PATCH 093/155] convertTo

---
 modules/core/src/cuda/matrix_operations.cu | 106 ++++++++++++++-------
 1 file changed, 73 insertions(+), 33 deletions(-)

diff --git a/modules/core/src/cuda/matrix_operations.cu b/modules/core/src/cuda/matrix_operations.cu
index 9e830e563..60aa07340 100644
--- a/modules/core/src/cuda/matrix_operations.cu
+++ b/modules/core/src/cuda/matrix_operations.cu
@@ -44,6 +44,7 @@
 #include "opencv2/gpu/device/saturate_cast.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/type_traits.hpp"
 
 namespace cv { namespace gpu { namespace device
 {
@@ -54,6 +55,7 @@ namespace cv { namespace gpu { namespace device
     void writeScalar(const int*);
     void writeScalar(const float*);
     void writeScalar(const double*);
+    void copyToWithMask_gpu(PtrStepSzb src, PtrStepSzb dst, size_t elemSize1, int cn, PtrStepSzb mask, bool colorMask, cudaStream_t stream);
     void convert_gpu(PtrStepSzb, int, PtrStepSzb, int, double, double, cudaStream_t);
 }}}
 
@@ -226,16 +228,16 @@ namespace cv { namespace gpu { namespace device
     //////////////////////////////// ConvertTo ////////////////////////////////
     ///////////////////////////////////////////////////////////////////////////
 
-    template <typename T, typename D> struct Convertor : unary_function<T, D>
+    template <typename T, typename D, typename S> struct Convertor : unary_function<T, D>
     {
-        Convertor(double alpha_, double beta_) : alpha(alpha_), beta(beta_) {}
+        Convertor(S alpha_, S beta_) : alpha(alpha_), beta(beta_) {}
 
-        __device__ __forceinline__ D operator()(const T& src) const
+        __device__ __forceinline__ D operator()(typename TypeTraits<T>::ParameterType src) const
         {
             return saturate_cast<D>(alpha * src + beta);
         }
 
-        double alpha, beta;
+        S alpha, beta;
     };
 
     namespace detail
@@ -282,16 +284,16 @@ namespace cv { namespace gpu { namespace device
         };
     }
 
-    template <typename T, typename D> struct TransformFunctorTraits< Convertor<T, D> > : detail::ConvertTraits< Convertor<T, D> >
+    template <typename T, typename D, typename S> struct TransformFunctorTraits< Convertor<T, D, S> > : detail::ConvertTraits< Convertor<T, D, S> >
     {
     };
 
-    template<typename T, typename D>
+    template<typename T, typename D, typename S>
     void cvt_(PtrStepSzb src, PtrStepSzb dst, double alpha, double beta, cudaStream_t stream)
     {
         cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
         cudaSafeCall( cudaSetDoubleForDevice(&beta) );
-        Convertor<T, D> op(alpha, beta);
+        Convertor<T, D, S> op(static_cast<S>(alpha), static_cast<S>(beta));
         cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
     }
 
@@ -304,36 +306,74 @@ namespace cv { namespace gpu { namespace device
     {
         typedef void (*caller_t)(PtrStepSzb src, PtrStepSzb dst, double alpha, double beta, cudaStream_t stream);
 
-        static const caller_t tab[8][8] =
+        static const caller_t tab[7][7] =
         {
-            {cvt_<uchar, uchar>, cvt_<uchar, schar>, cvt_<uchar, ushort>, cvt_<uchar, short>,
-            cvt_<uchar, int>, cvt_<uchar, float>, cvt_<uchar, double>, 0},
-
-            {cvt_<schar, uchar>, cvt_<schar, schar>, cvt_<schar, ushort>, cvt_<schar, short>,
-            cvt_<schar, int>, cvt_<schar, float>, cvt_<schar, double>, 0},
-
-            {cvt_<ushort, uchar>, cvt_<ushort, schar>, cvt_<ushort, ushort>, cvt_<ushort, short>,
-            cvt_<ushort, int>, cvt_<ushort, float>, cvt_<ushort, double>, 0},
-
-            {cvt_<short, uchar>, cvt_<short, schar>, cvt_<short, ushort>, cvt_<short, short>,
-            cvt_<short, int>, cvt_<short, float>, cvt_<short, double>, 0},
-
-            {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}
+            {
+                cvt_<uchar, uchar, float>,
+                cvt_<uchar, schar, float>,
+                cvt_<uchar, ushort, float>,
+                cvt_<uchar, short, float>,
+                cvt_<uchar, int, float>,
+                cvt_<uchar, float, float>,
+                cvt_<uchar, double, double>
+            },
+            {
+                cvt_<schar, uchar, float>,
+                cvt_<schar, schar, float>,
+                cvt_<schar, ushort, float>,
+                cvt_<schar, short, float>,
+                cvt_<schar, int, float>,
+                cvt_<schar, float, float>,
+                cvt_<schar, double, double>
+            },
+            {
+                cvt_<ushort, uchar, float>,
+                cvt_<ushort, schar, float>,
+                cvt_<ushort, ushort, float>,
+                cvt_<ushort, short, float>,
+                cvt_<ushort, int, float>,
+                cvt_<ushort, float, float>,
+                cvt_<ushort, double, double>
+            },
+            {
+                cvt_<short, uchar, float>,
+                cvt_<short, schar, float>,
+                cvt_<short, ushort, float>,
+                cvt_<short, short, float>,
+                cvt_<short, int, float>,
+                cvt_<short, float, float>,
+                cvt_<short, double, double>
+            },
+            {
+                cvt_<int, uchar, float>,
+                cvt_<int, schar, float>,
+                cvt_<int, ushort, float>,
+                cvt_<int, short, float>,
+                cvt_<int, int, double>,
+                cvt_<int, float, double>,
+                cvt_<int, double, double>
+            },
+            {
+                cvt_<float, uchar, float>,
+                cvt_<float, schar, float>,
+                cvt_<float, ushort, float>,
+                cvt_<float, short, float>,
+                cvt_<float, int, float>,
+                cvt_<float, float, float>,
+                cvt_<float, double, double>
+            },
+            {
+                cvt_<double, uchar, double>,
+                cvt_<double, schar, double>,
+                cvt_<double, ushort, double>,
+                cvt_<double, short, double>,
+                cvt_<double, int, double>,
+                cvt_<double, float, double>,
+                cvt_<double, double, double>
+            }
         };
 
         caller_t func = tab[sdepth][ddepth];
-        if (!func)
-            cv::gpu::error("Unsupported convert operation", __FILE__, __LINE__, "convert_gpu");
-
         func(src, dst, alpha, beta, stream);
     }
 

From f00efcfc593b361f875b1b85c2684850cd192974 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 23 Nov 2012 18:36:15 +0400
Subject: [PATCH 094/155] added optimized deviceSupports function

---
 modules/core/include/opencv2/core/gpumat.hpp |   2 +
 modules/core/src/gpumat.cpp                  | 118 +++++++++++++++----
 2 files changed, 100 insertions(+), 20 deletions(-)

diff --git a/modules/core/include/opencv2/core/gpumat.hpp b/modules/core/include/opencv2/core/gpumat.hpp
index 73da7e7a8..6bf4e5d21 100644
--- a/modules/core/include/opencv2/core/gpumat.hpp
+++ b/modules/core/include/opencv2/core/gpumat.hpp
@@ -79,6 +79,8 @@ namespace cv { namespace gpu
         WARP_SHUFFLE_FUNCTIONS = FEATURE_SET_COMPUTE_30
     };
 
+    CV_EXPORTS bool deviceSupports(FeatureSet feature_set);
+
     // Gives information about what GPU archs this OpenCV GPU module was
     // compiled for
     class CV_EXPORTS TargetArchs
diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
index afd7115b0..6b5b076cd 100644
--- a/modules/core/src/gpumat.cpp
+++ b/modules/core/src/gpumat.cpp
@@ -69,33 +69,89 @@ using namespace cv::gpu;
 
 namespace
 {
-    // Compares value to set using the given comparator. Returns true if
-    // there is at least one element x in the set satisfying to: x cmp value
-    // predicate.
-    template <typename Comparer>
-    bool compareToSet(const std::string& set_as_str, int value, Comparer cmp)
+    class CudaArch
+    {
+    public:
+        CudaArch();
+
+        bool builtWith(FeatureSet feature_set) const;
+        bool hasPtx(int major, int minor) const;
+        bool hasBin(int major, int minor) const;
+        bool hasEqualOrLessPtx(int major, int minor) const;
+        bool hasEqualOrGreaterPtx(int major, int minor) const;
+        bool hasEqualOrGreaterBin(int major, int minor) const;
+
+    private:
+        static void fromStr(const string& set_as_str, vector<int>& arr);
+
+        vector<int> bin;
+        vector<int> ptx;
+        vector<int> features;
+    };
+
+    const CudaArch cudaArch;
+
+    CudaArch::CudaArch()
+    {
+    #ifdef HAVE_CUDA
+        fromStr(CUDA_ARCH_BIN, bin);
+        fromStr(CUDA_ARCH_PTX, ptx);
+        fromStr(CUDA_ARCH_FEATURES, features);
+    #endif
+    }
+
+    bool CudaArch::builtWith(FeatureSet feature_set) const
+    {
+        return !features.empty() && (features.back() >= feature_set);
+    }
+
+    bool CudaArch::hasPtx(int major, int minor) const
+    {
+        return find(ptx.begin(), ptx.end(), major * 10 + minor) != ptx.end();
+    }
+
+    bool CudaArch::hasBin(int major, int minor) const
+    {
+        return find(bin.begin(), bin.end(), major * 10 + minor) != bin.end();
+    }
+
+    bool CudaArch::hasEqualOrLessPtx(int major, int minor) const
+    {
+        return !ptx.empty() && (ptx.front() <= major * 10 + minor);
+    }
+
+    bool CudaArch::hasEqualOrGreaterPtx(int major, int minor) const
+    {
+        return !ptx.empty() && (ptx.back() >= major * 10 + minor);
+    }
+
+    bool CudaArch::hasEqualOrGreaterBin(int major, int minor) const
+    {
+        return !bin.empty() && (bin.back() >= major * 10 + minor);
+    }
+
+    void CudaArch::fromStr(const string& set_as_str, vector<int>& arr)
     {
         if (set_as_str.find_first_not_of(" ") == string::npos)
-            return false;
+            return;
 
-        std::stringstream stream(set_as_str);
+        istringstream stream(set_as_str);
         int cur_value;
 
         while (!stream.eof())
         {
             stream >> cur_value;
-            if (cmp(cur_value, value))
-                return true;
+            arr.push_back(cur_value);
         }
 
-        return false;
+        sort(arr.begin(), arr.end());
     }
 }
 
 bool cv::gpu::TargetArchs::builtWith(cv::gpu::FeatureSet feature_set)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_FEATURES, feature_set, std::greater_equal<int>());
+    return cudaArch.builtWith(feature_set);
 #else
     (void)feature_set;
     return false;
@@ -110,7 +166,7 @@ bool cv::gpu::TargetArchs::has(int major, int minor)
 bool cv::gpu::TargetArchs::hasPtx(int major, int minor)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor, std::equal_to<int>());
+    return cudaArch.hasPtx(major, minor);
 #else
     (void)major;
     (void)minor;
@@ -121,7 +177,7 @@ bool cv::gpu::TargetArchs::hasPtx(int major, int minor)
 bool cv::gpu::TargetArchs::hasBin(int major, int minor)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_BIN, major * 10 + minor, std::equal_to<int>());
+    return cudaArch.hasBin(major, minor);
 #else
     (void)major;
     (void)minor;
@@ -132,8 +188,7 @@ bool cv::gpu::TargetArchs::hasBin(int major, int minor)
 bool cv::gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor,
-                     std::less_equal<int>());
+    return cudaArch.hasEqualOrLessPtx(major, minor);
 #else
     (void)major;
     (void)minor;
@@ -143,14 +198,13 @@ bool cv::gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor)
 
 bool cv::gpu::TargetArchs::hasEqualOrGreater(int major, int minor)
 {
-    return hasEqualOrGreaterPtx(major, minor) ||
-           hasEqualOrGreaterBin(major, minor);
+    return hasEqualOrGreaterPtx(major, minor) || hasEqualOrGreaterBin(major, minor);
 }
 
 bool cv::gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_PTX, major * 10 + minor, std::greater_equal<int>());
+    return cudaArch.hasEqualOrGreaterPtx(major, minor);
 #else
     (void)major;
     (void)minor;
@@ -161,8 +215,7 @@ bool cv::gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor)
 bool cv::gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor)
 {
 #if defined (HAVE_CUDA)
-    return ::compareToSet(CUDA_ARCH_BIN, major * 10 + minor,
-                     std::greater_equal<int>());
+    return cudaArch.hasEqualOrGreaterBin(major, minor);
 #else
     (void)major;
     (void)minor;
@@ -170,6 +223,31 @@ bool cv::gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor)
 #endif
 }
 
+bool cv::gpu::deviceSupports(FeatureSet feature_set)
+{
+    static int versions[] =
+    {
+        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+    };
+    static const int cache_size = static_cast<int>(sizeof(versions) / sizeof(versions[0]));
+
+    const int devId = getDevice();
+
+    int version;
+
+    if (devId < cache_size && versions[devId] >= 0)
+        version = versions[devId];
+    else
+    {
+        DeviceInfo dev(devId);
+        version = dev.majorVersion() * 10 + dev.minorVersion();
+        if (devId < cache_size)
+            versions[devId] = version;
+    }
+
+    return TargetArchs::builtWith(feature_set) && (version >= feature_set);
+}
+
 #if !defined (HAVE_CUDA)
 
 #define throw_nogpu CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support")

From 11c6eb63051d9160865436db3cdf69987bc5fe06 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov47@gmail.com>
Date: Wed, 21 Nov 2012 12:46:11 +0400
Subject: [PATCH 095/155] element operations

---
 .../include/opencv2/gpu/device/functional.hpp |   34 +
 modules/gpu/src/cuda/element_operations.cu    | 4366 +++++++++++------
 modules/gpu/src/element_operations.cpp        | 3494 ++++++++-----
 modules/gpu/test/test_core.cpp                |  144 +-
 4 files changed, 5066 insertions(+), 2972 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/functional.hpp b/modules/gpu/include/opencv2/gpu/device/functional.hpp
index 6e0471e9a..cd63c3ac9 100644
--- a/modules/gpu/include/opencv2/gpu/device/functional.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/functional.hpp
@@ -357,6 +357,9 @@ namespace cv { namespace gpu { namespace device
         {
             return abs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<unsigned char> : unary_function<unsigned char, unsigned char>
     {
@@ -364,6 +367,9 @@ namespace cv { namespace gpu { namespace device
         {
             return x;
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<signed char> : unary_function<signed char, signed char>
     {
@@ -371,6 +377,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::abs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<char> : unary_function<char, char>
     {
@@ -378,6 +387,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::abs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<unsigned short> : unary_function<unsigned short, unsigned short>
     {
@@ -385,6 +397,9 @@ namespace cv { namespace gpu { namespace device
         {
             return x;
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<short> : unary_function<short, short>
     {
@@ -392,6 +407,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::abs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<unsigned int> : unary_function<unsigned int, unsigned int>
     {
@@ -399,6 +417,9 @@ namespace cv { namespace gpu { namespace device
         {
             return x;
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<int> : unary_function<int, int>
     {
@@ -406,6 +427,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::abs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<float> : unary_function<float, float>
     {
@@ -413,6 +437,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::fabsf(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
     template <> struct abs_func<double> : unary_function<double, double>
     {
@@ -420,6 +447,9 @@ namespace cv { namespace gpu { namespace device
         {
             return ::fabs(x);
         }
+
+        __device__ __forceinline__ abs_func() {}
+        __device__ __forceinline__ abs_func(const abs_func&) {}
     };
 
 #define OPENCV_GPU_IMPLEMENT_UN_FUNCTOR(name, func) \
@@ -429,6 +459,8 @@ namespace cv { namespace gpu { namespace device
         { \
             return func ## f(v); \
         } \
+        __device__ __forceinline__ name ## _func() {} \
+        __device__ __forceinline__ name ## _func(const name ## _func&) {} \
     }; \
     template <> struct name ## _func<double> : unary_function<double, double> \
     { \
@@ -436,6 +468,8 @@ namespace cv { namespace gpu { namespace device
         { \
             return func(v); \
         } \
+        __device__ __forceinline__ name ## _func() {} \
+        __device__ __forceinline__ name ## _func(const name ## _func&) {} \
     };
 
 #define OPENCV_GPU_IMPLEMENT_BIN_FUNCTOR(name, func) \
diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index c61601d4f..eaf577bac 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -42,405 +42,833 @@
 
 #if !defined CUDA_DISABLER
 
-#include "internal_shared.hpp"
+#include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/functional.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
 #include "opencv2/gpu/device/transform.hpp"
 #include "opencv2/gpu/device/limits.hpp"
 #include "opencv2/gpu/device/saturate_cast.hpp"
 
-namespace cv { namespace gpu { namespace device
-{
-    //////////////////////////////////////////////////////////////////////////
-    // add
+using namespace cv::gpu;
+using namespace cv::gpu::device;
 
-    template <typename T, typename D> struct Add : binary_function<T, T, D>
+//////////////////////////////////////////////////////////////////////////
+// addMat
+
+namespace
+{
+    template <typename T, typename D> struct VAdd4;
+    template <> struct VAdd4<uint, uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd4.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.u32.u32.u32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.u32.u32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.u32.u32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.u32.u32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd4() {}
+        __device__ __forceinline__ VAdd4(const VAdd4<uint, uint>& other) {}
+    };
+    template <> struct VAdd4<int, uint> : binary_function<int, int, uint>
+    {
+        __device__ __forceinline__ uint operator ()(int a, int b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd4.u32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.u32.s32.s32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.s32.s32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.s32.s32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.s32.s32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd4() {}
+        __device__ __forceinline__ VAdd4(const VAdd4<int, uint>& other) {}
+    };
+    template <> struct VAdd4<uint, int> : binary_function<uint, uint, int>
+    {
+        __device__ __forceinline__ int operator ()(uint a, uint b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd4.s32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.s32.u32.u32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.u32.u32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.u32.u32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.u32.u32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd4() {}
+        __device__ __forceinline__ VAdd4(const VAdd4<uint, int>& other) {}
+    };
+    template <> struct VAdd4<int, int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd4.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.s32.s32.s32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.s32.s32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.s32.s32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.s32.s32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd4() {}
+        __device__ __forceinline__ VAdd4(const VAdd4<int, int>& other) {}
+    };
+
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct VAdd2;
+    template <> struct VAdd2<uint, uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd2.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.u32.u32.u32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.u32.u32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd2() {}
+        __device__ __forceinline__ VAdd2(const VAdd2<uint, uint>& other) {}
+    };
+    template <> struct VAdd2<uint, int> : binary_function<uint, uint, int>
+    {
+        __device__ __forceinline__ int operator ()(uint a, uint b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd2.s32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.s32.u32.u32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.u32.u32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd2() {}
+        __device__ __forceinline__ VAdd2(const VAdd2<uint, int>& other) {}
+    };
+    template <> struct VAdd2<int, uint> : binary_function<int, int, uint>
+    {
+        __device__ __forceinline__ uint operator ()(int a, int b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd2.u32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.u32.s32.s32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.u32.s32.s32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd2() {}
+        __device__ __forceinline__ VAdd2(const VAdd2<int, uint>& other) {}
+    };
+    template <> struct VAdd2<int, int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vadd2.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vadd.s32.s32.s32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vadd.s32.s32.s32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAdd2() {}
+        __device__ __forceinline__ VAdd2(const VAdd2<int, int>& other) {}
+    };
+
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct AddMat : binary_function<T, T, D>
     {
         __device__ __forceinline__ D operator ()(T a, T b) const
         {
             return saturate_cast<D>(a + b);
         }
+
+        __device__ __forceinline__ AddMat() {}
+        __device__ __forceinline__ AddMat(const AddMat& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T, typename D> struct TransformFunctorTraits< VAdd4<T, D> > : DefaultTransformFunctorTraits< VAdd4<T, D> >
+    {
+        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< Add<ushort, ushort> > : DefaultTransformFunctorTraits< Add<ushort, ushort> >
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct TransformFunctorTraits< VAdd2<T, D> > : DefaultTransformFunctorTraits< VAdd4<T, D> >
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Add<short, short> > : DefaultTransformFunctorTraits< Add<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Add<int, int> > : DefaultTransformFunctorTraits< Add<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Add<float, float> > : DefaultTransformFunctorTraits< Add<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        enum { smart_shift = 2 };
     };
 
-    template <typename T, typename D> void add_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream)
+    ////////////////////////////////////
+
+    template <> struct TransformFunctorTraits< AddMat<ushort, ushort> > : DefaultTransformFunctorTraits< AddMat<ushort, ushort> >
     {
-        if (mask.data)
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, Add<T, D>(), SingleMask(mask), stream);
-        else
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, Add<T, D>(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AddMat<short, short> > : DefaultTransformFunctorTraits< AddMat<short, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AddMat<int, int> > : DefaultTransformFunctorTraits< AddMat<int, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AddMat<float, float> > : DefaultTransformFunctorTraits< AddMat<float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T, typename D>
+    void vadd4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, VAdd4<T, D>(), WithOutMask(), stream);
     }
 
-    template void add_gpu<uchar, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<uchar, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void vadd4<uint, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd4<uint, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd4<int, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd4<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void add_gpu<schar, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<ushort, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<short, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<int, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<float, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void add_gpu<double, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<double, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    template <typename T, typename D> struct AddScalar : unary_function<T, D>
+    template <typename T, typename D>
+    void vadd2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        AddScalar(double val_) : val(val_) {}
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, VAdd2<T, D>(), WithOutMask(), stream);
+    }
+
+    template void vadd2<uint, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd2<uint, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd2<int, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vadd2<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T, typename D>
+    void addMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, AddMat<T, D>(), WithOutMask(), stream);
+    }
+
+    template void addMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<uchar, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    template void addMat<schar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<schar, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void addMat<ushort, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<ushort, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<ushort, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<ushort, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<ushort, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<ushort, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<ushort, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void addMat<short, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<short, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<short, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<short, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<short, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<short, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<short, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void addMat<int, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<int, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<int, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<int, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<int, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<int, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void addMat<float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<float, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void addMat<double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<double, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<double, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<double, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addMat<double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addMat<double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// addScalar
+
+namespace
+{
+    template <typename T, typename S, typename D> struct AddScalar : unary_function<T, D>
+    {
+        S val;
+
+        explicit AddScalar(S val_) : val(val_) {}
+
         __device__ __forceinline__ D operator ()(T a) const
         {
             return saturate_cast<D>(a + val);
         }
-        const double val;
     };
+}
 
-    template <> struct TransformFunctorTraits< AddScalar<ushort, ushort> > : DefaultTransformFunctorTraits< AddScalar<ushort, ushort>  >
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< AddScalar<ushort, float, ushort> > : DefaultTransformFunctorTraits< AddScalar<ushort, float, ushort>  >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddScalar<short, short> > : DefaultTransformFunctorTraits< AddScalar<short, short> >
+    template <> struct TransformFunctorTraits< AddScalar<short, float, short> > : DefaultTransformFunctorTraits< AddScalar<short, float, short> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddScalar<int, int> > : DefaultTransformFunctorTraits< AddScalar<int, int> >
+    template <> struct TransformFunctorTraits< AddScalar<int, float, int> > : DefaultTransformFunctorTraits< AddScalar<int, float, int> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddScalar<float, float> > : DefaultTransformFunctorTraits< AddScalar<float, float> >
+    template <> struct TransformFunctorTraits< AddScalar<float, float, float> > : DefaultTransformFunctorTraits< AddScalar<float, float, float> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
+}}}
 
-    template <typename T, typename D> void add_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream)
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void addScalar(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        AddScalar<T, D> op(val);
+        AddScalar<T, S, D> op(static_cast<S>(val));
+
         if (mask.data)
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, SingleMask(mask), stream);
+            transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
         else
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
+            transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
     }
 
-    template void add_gpu<uchar, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<uchar, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<uchar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void addScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<uchar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<schar, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<schar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void addScalar<schar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<schar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<ushort, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<ushort, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<ushort, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void addScalar<ushort, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<ushort, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<ushort, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<ushort, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<ushort, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<ushort, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<ushort, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<short, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<short, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<short, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void addScalar<short, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<short, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<short, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<short, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<short, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<short, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<short, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<int, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<int, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<int, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void addScalar<int, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<int, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<int, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<int, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<int, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<int, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<int, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<float, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<float, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<float, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void addScalar<float, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<float, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void add_gpu<double, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void add_gpu<double, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void add_gpu<double, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void addScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<double, double, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<double, double, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<double, double, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void addScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void addScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////
-    // subtract
+//////////////////////////////////////////////////////////////////////////
+// subMat
 
-    template <typename T, typename D> struct Subtract : binary_function<T, T, D>
+namespace
+{
+    template <typename T, typename D> struct VSub4;
+    template <> struct VSub4<uint, uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub4.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.u32.u32.u32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.u32.u32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.u32.u32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.u32.u32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub4() {}
+        __device__ __forceinline__ VSub4(const VSub4<uint, uint>& other) {}
+    };
+    template <> struct VSub4<int, uint> : binary_function<int, int, uint>
+    {
+        __device__ __forceinline__ uint operator ()(int a, int b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub4.u32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.u32.s32.s32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.s32.s32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.s32.s32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.s32.s32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub4() {}
+        __device__ __forceinline__ VSub4(const VSub4<int, uint>& other) {}
+    };
+    template <> struct VSub4<uint, int> : binary_function<uint, uint, int>
+    {
+        __device__ __forceinline__ int operator ()(uint a, uint b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub4.s32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.s32.u32.u32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.u32.u32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.u32.u32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.u32.u32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub4() {}
+        __device__ __forceinline__ VSub4(const VSub4<uint, int>& other) {}
+    };
+    template <> struct VSub4<int, int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub4.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.s32.s32.s32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.s32.s32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.s32.s32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.s32.s32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub4() {}
+        __device__ __forceinline__ VSub4(const VSub4<int, int>& other) {}
+    };
+
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct VSub2;
+    template <> struct VSub2<uint, uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub2.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.u32.u32.u32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.u32.u32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub2() {}
+        __device__ __forceinline__ VSub2(const VSub2<uint, uint>& other) {}
+    };
+    template <> struct VSub2<uint, int> : binary_function<uint, uint, int>
+    {
+        __device__ __forceinline__ int operator ()(uint a, uint b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub2.s32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.s32.u32.u32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.u32.u32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub2() {}
+        __device__ __forceinline__ VSub2(const VSub2<uint, int>& other) {}
+    };
+    template <> struct VSub2<int, uint> : binary_function<int, int, uint>
+    {
+        __device__ __forceinline__ uint operator ()(int a, int b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub2.u32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.u32.s32.s32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.u32.s32.s32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub2() {}
+        __device__ __forceinline__ VSub2(const VSub2<int, uint>& other) {}
+    };
+    template <> struct VSub2<int, int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vsub2.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vsub.s32.s32.s32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vsub.s32.s32.s32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VSub2() {}
+        __device__ __forceinline__ VSub2(const VSub2<int, int>& other) {}
+    };
+
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct SubMat : binary_function<T, T, D>
     {
         __device__ __forceinline__ D operator ()(T a, T b) const
         {
             return saturate_cast<D>(a - b);
         }
+
+        __device__ __forceinline__ SubMat() {}
+        __device__ __forceinline__ SubMat(const SubMat& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T, typename D> struct TransformFunctorTraits< VSub4<T, D> > : DefaultTransformFunctorTraits< VSub4<T, D> >
+    {
+        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< Subtract<ushort, ushort> > : DefaultTransformFunctorTraits< Subtract<ushort, ushort> >
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct TransformFunctorTraits< VSub2<T, D> > : DefaultTransformFunctorTraits< VSub2<T, D> >
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Subtract<short, short> > : DefaultTransformFunctorTraits< Subtract<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Subtract<int, int> > : DefaultTransformFunctorTraits< Subtract<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Subtract<float, float> > : DefaultTransformFunctorTraits< Subtract<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        enum { smart_shift = 2 };
     };
 
-    template <typename T, typename D> void subtract_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream)
+    ////////////////////////////////////
+
+    template <> struct TransformFunctorTraits< SubMat<ushort, ushort> > : DefaultTransformFunctorTraits< SubMat<ushort, ushort> >
     {
-        if (mask.data)
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, Subtract<T, D>(), SingleMask(mask), stream);
-        else
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, Subtract<T, D>(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< SubMat<short, short> > : DefaultTransformFunctorTraits< SubMat<short, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< SubMat<int, int> > : DefaultTransformFunctorTraits< SubMat<int, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< SubMat<float, float> > : DefaultTransformFunctorTraits< SubMat<float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T, typename D>
+    void vsub4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, VSub4<T, D>(), WithOutMask(), stream);
     }
 
-    template void subtract_gpu<uchar, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<uchar, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void vsub4<uint, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub4<uint, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub4<int, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub4<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void subtract_gpu<schar, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<ushort, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<short, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<int, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<float, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    //template void subtract_gpu<double, uchar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, schar>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, short>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, int>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, float>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<double, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-
-    template <typename T, typename D> struct SubtractScalar : unary_function<T, D>
+    template <typename T, typename D>
+    void vsub2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        SubtractScalar(double val_) : val(val_) {}
-        __device__ __forceinline__ D operator ()(T a) const
-        {
-            return saturate_cast<D>(a - val);
-        }
-        const double val;
-    };
-
-    template <> struct TransformFunctorTraits< SubtractScalar<ushort, ushort> > : DefaultTransformFunctorTraits< SubtractScalar<ushort, ushort>  >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubtractScalar<short, short> > : DefaultTransformFunctorTraits< SubtractScalar<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubtractScalar<int, int> > : DefaultTransformFunctorTraits< SubtractScalar<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubtractScalar<float, float> > : DefaultTransformFunctorTraits< SubtractScalar<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <typename T, typename D> void subtract_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream)
-    {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        SubtractScalar<T, D> op(val);
-        if (mask.data)
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, SingleMask(mask), stream);
-        else
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, VSub2<T, D>(), WithOutMask(), stream);
     }
 
-    template void subtract_gpu<uchar, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<uchar, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<uchar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void vsub2<uint, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub2<uint, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub2<int, uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vsub2<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void subtract_gpu<schar, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<schar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template <typename T, typename D>
+    void subMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, SubMat<T, D>(), WithOutMask(), stream);
+    }
 
-    //template void subtract_gpu<ushort, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<ushort, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<ushort, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void subMat<uchar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<uchar, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void subtract_gpu<short, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<short, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<short, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    template void subMat<schar, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<schar, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void subtract_gpu<int, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<int, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<int, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void subMat<ushort, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<ushort, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<ushort, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<ushort, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<ushort, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<ushort, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<ushort, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void subtract_gpu<float, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<float, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<float, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void subMat<short, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<short, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<short, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<short, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<short, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<short, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<short, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //template void subtract_gpu<double, uchar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, schar>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, short>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, int>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    //template void subtract_gpu<double, float>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-    template void subtract_gpu<double, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    //template void subMat<int, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<int, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<int, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<int, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<int, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<int, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<int, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    //////////////////////////////////////////////////////////////////////////
-    // multiply
+    //template void subMat<float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<float, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 
-    struct multiply_8uc4_32f : binary_function<uint, float, uint>
+    //template void subMat<double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<double, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<double, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<double, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subMat<double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subMat<double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// subScalar
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void subScalar(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        AddScalar<T, S, D> op(-static_cast<S>(val));
+
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+    }
+
+    template void subScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<uchar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    template void subScalar<schar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<schar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void subScalar<ushort, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<ushort, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<ushort, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<ushort, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<ushort, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<ushort, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<ushort, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void subScalar<short, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<short, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<short, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<short, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<short, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<short, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<short, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void subScalar<int, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<int, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<int, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<int, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<int, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<int, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<int, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void subScalar<float, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<float, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    //template void subScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<double, double, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<double, double, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<double, double, short>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    //template void subScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void subScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// mulMat
+
+namespace
+{
+    struct Mul_8uc4_32f : binary_function<uint, float, uint>
     {
         __device__ __forceinline__ uint operator ()(uint a, float b) const
         {
@@ -453,301 +881,316 @@ namespace cv { namespace gpu { namespace device
 
             return res;
         }
+
+        __device__ __forceinline__ Mul_8uc4_32f() {}
+        __device__ __forceinline__ Mul_8uc4_32f(const Mul_8uc4_32f& other) {}
     };
 
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(multiply_8uc4_32f)
-    {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
-    };
-
-    void multiply_gpu(const PtrStepSz<uchar4>& src1, const PtrStepSzf& src2, const PtrStepSz<uchar4>& dst, cudaStream_t stream)
-    {
-        cv::gpu::device::transform(static_cast< PtrStepSz<uint> >(src1), src2, static_cast< PtrStepSz<uint> >(dst), multiply_8uc4_32f(), WithOutMask(), stream);
-    }
-
-    struct multiply_16sc4_32f : binary_function<short4, float, short4>
+    struct Mul_16sc4_32f : binary_function<short4, float, short4>
     {
         __device__ __forceinline__ short4 operator ()(short4 a, float b) const
         {
             return make_short4(saturate_cast<short>(a.x * b), saturate_cast<short>(a.y * b),
                                saturate_cast<short>(a.z * b), saturate_cast<short>(a.w * b));
         }
+
+        __device__ __forceinline__ Mul_16sc4_32f() {}
+        __device__ __forceinline__ Mul_16sc4_32f(const Mul_16sc4_32f& other) {}
     };
 
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(multiply_16sc4_32f)
+    template <typename T, typename D> struct Mul : binary_function<T, T, D>
     {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
+        __device__ __forceinline__ D operator ()(T a, T b) const
+        {
+            return saturate_cast<D>(a * b);
+        }
+
+        __device__ __forceinline__ Mul() {}
+        __device__ __forceinline__ Mul(const Mul& other) {}
     };
 
-    void multiply_gpu(const PtrStepSz<short4>& src1, const PtrStepSzf& src2, const PtrStepSz<short4>& dst, cudaStream_t stream)
+    template <typename T, typename S, typename D> struct MulScale : binary_function<T, T, D>
     {
-        cv::gpu::device::transform(static_cast< PtrStepSz<short4> >(src1), src2, static_cast< PtrStepSz<short4> >(dst), multiply_16sc4_32f(), WithOutMask(), stream);
-    }
+        S scale;
+
+        explicit MulScale(S scale_) : scale(scale_) {}
 
-    template <typename T, typename D> struct Multiply : binary_function<T, T, D>
-    {
-        Multiply(float scale_) : scale(scale_) {}
         __device__ __forceinline__ D operator ()(T a, T b) const
         {
             return saturate_cast<D>(scale * a * b);
         }
-        const float scale;
-    };
-    template <typename T> struct Multiply<T, double> : binary_function<T, T, double>
-    {
-        Multiply(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ double operator ()(T a, T b) const
-        {
-            return scale * a * b;
-        }
-        const double scale;
-    };
-    template <> struct Multiply<int, int> : binary_function<int, int, int>
-    {
-        Multiply(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ int operator ()(int a, int b) const
-        {
-            return saturate_cast<int>(scale * a * b);
-        }
-        const double scale;
     };
+}
 
-    template <> struct TransformFunctorTraits< Multiply<ushort, ushort> > : DefaultTransformFunctorTraits< Multiply<ushort, ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Multiply<short, short> > : DefaultTransformFunctorTraits< Multiply<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Multiply<int, int> > : DefaultTransformFunctorTraits< Multiply<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Multiply<float, float> > : DefaultTransformFunctorTraits< Multiply<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <typename T, typename D> struct MultiplyCaller
-    {
-        static void call(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-        {
-            Multiply<T, D> op(static_cast<float>(scale));
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
-        }
-    };
-    template <typename T> struct MultiplyCaller<T, double>
-    {
-        static void call(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-        {
-            cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-            Multiply<T, double> op(scale);
-            cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<double>)dst, op, WithOutMask(), stream);
-        }
-    };
-    template <> struct MultiplyCaller<int, int>
-    {
-        static void call(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-        {
-            cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-            Multiply<int, int> op(scale);
-            cv::gpu::device::transform((PtrStepSz<int>)src1, (PtrStepSz<int>)src2, (PtrStepSz<int>)dst, op, WithOutMask(), stream);
-        }
-    };
-
-    template <typename T, typename D> void multiply_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-    {
-        MultiplyCaller<T, D>::call(src1, src2, dst, scale, stream);
-    }
-
-    template void multiply_gpu<uchar, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<uchar, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<schar, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<ushort, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<short, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<int, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<float, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<double, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<double, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    template <typename T, typename D> struct MultiplyScalar : unary_function<T, D>
-    {
-        MultiplyScalar(double val_, double scale_) : val(val_), scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a) const
-        {
-            return saturate_cast<D>(scale * a * val);
-        }
-        const double val;
-        const double scale;
-    };
-
-    template <> struct TransformFunctorTraits< MultiplyScalar<ushort, ushort> > : DefaultTransformFunctorTraits< MultiplyScalar<ushort, ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MultiplyScalar<short, short> > : DefaultTransformFunctorTraits< MultiplyScalar<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MultiplyScalar<int, int> > : DefaultTransformFunctorTraits< MultiplyScalar<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MultiplyScalar<float, float> > : DefaultTransformFunctorTraits< MultiplyScalar<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <typename T, typename D> void multiply_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-    {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        MultiplyScalar<T, D> op(val, scale);
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
-    }
-
-    template void multiply_gpu<uchar, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<uchar, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<uchar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<schar, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<schar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<ushort, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<ushort, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<ushort, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<short, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<short, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<short, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<int, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<int, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<int, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<float, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<float, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<float, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //template void multiply_gpu<double, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void multiply_gpu<double, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void multiply_gpu<double, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////
-    // divide
-
-    struct divide_8uc4_32f : binary_function<uchar4, float, uchar4>
-    {
-        __device__ __forceinline__ uchar4 operator ()(uchar4 a, float b) const
-        {
-            return b != 0 ? make_uchar4(saturate_cast<uchar>(a.x / b), saturate_cast<uchar>(a.y / b),
-                                        saturate_cast<uchar>(a.z / b), saturate_cast<uchar>(a.w / b))
-                          : make_uchar4(0,0,0,0);
-        }
-    };
-
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(divide_8uc4_32f)
+namespace cv { namespace gpu { namespace device
+{
+    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(Mul_8uc4_32f)
     {
         enum { smart_block_dim_x = 8 };
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 8 };
     };
 
-    void divide_gpu(const PtrStepSz<uchar4>& src1, const PtrStepSzf& src2, const PtrStepSz<uchar4>& dst, cudaStream_t stream)
+    template <> struct TransformFunctorTraits< Mul<ushort, ushort> > : DefaultTransformFunctorTraits< Mul<ushort, ushort> >
     {
-        cv::gpu::device::transform(static_cast< PtrStepSz<uchar4> >(src1), src2, static_cast< PtrStepSz<uchar4> >(dst), divide_8uc4_32f(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Mul<short, short> > : DefaultTransformFunctorTraits< Mul<short, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Mul<int, int> > : DefaultTransformFunctorTraits< Mul<int, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Mul<float, float> > : DefaultTransformFunctorTraits< Mul<float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct TransformFunctorTraits< MulScale<ushort, float, ushort> > : DefaultTransformFunctorTraits< MulScale<ushort, float, ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScale<short, float, short> > : DefaultTransformFunctorTraits< MulScale<short, float, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScale<int, float, int> > : DefaultTransformFunctorTraits< MulScale<int, float, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScale<float, float, float> > : DefaultTransformFunctorTraits< MulScale<float, float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    void mulMat_8uc4_32f(PtrStepSz<uint> src1, PtrStepSzf src2, PtrStepSz<uint> dst, cudaStream_t stream)
+    {
+        transform(src1, src2, dst, Mul_8uc4_32f(), WithOutMask(), stream);
     }
 
+    void mulMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream)
+    {
+        transform(src1, src2, dst, Mul_16sc4_32f(), WithOutMask(), stream);
+    }
 
-    struct divide_16sc4_32f : binary_function<short4, float, short4>
+    template <typename T, typename S, typename D>
+    void mulMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream)
+    {
+        if (scale == 1)
+        {
+            Mul<T, D> op;
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+        }
+        else
+        {
+            MulScale<T, S, D> op(static_cast<S>(scale));
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+        }
+    }
+
+    template void mulMat<uchar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<uchar, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    template void mulMat<schar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<schar, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    //template void mulMat<ushort, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<ushort, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<ushort, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<ushort, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<ushort, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<ushort, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<ushort, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    //template void mulMat<short, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<short, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<short, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<short, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<short, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<short, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<short, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    //template void mulMat<int, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<int, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<int, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<int, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<int, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<int, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<int, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    //template void mulMat<float, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<float, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<float, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<float, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<float, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<float, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<float, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+
+    //template void mulMat<double, double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<double, double, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<double, double, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<double, double, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<double, double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void mulMat<double, double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void mulMat<double, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// mulScalar
+
+namespace
+{
+    template <typename T, typename S, typename D> struct MulScalar : unary_function<T, D>
+    {
+        S val;
+
+        explicit MulScalar(S val_) : val(val_) {}
+
+        __device__ __forceinline__ D operator ()(T a) const
+        {
+            return saturate_cast<D>(a * val);
+        }
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< MulScalar<ushort, float, ushort> > : DefaultTransformFunctorTraits< MulScalar<ushort, float, ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScalar<short, float, short> > : DefaultTransformFunctorTraits< MulScalar<short, float, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScalar<int, float, int> > : DefaultTransformFunctorTraits< MulScalar<int, float, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< MulScalar<float, float, float> > : DefaultTransformFunctorTraits< MulScalar<float, float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void mulScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
+    {
+        MulScalar<T, S, D> op(static_cast<S>(val));
+        transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+    }
+
+    template void mulScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<uchar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    template void mulScalar<schar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<schar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void mulScalar<ushort, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<ushort, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<ushort, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<ushort, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<ushort, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<ushort, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<ushort, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void mulScalar<short, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<short, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<short, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<short, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<short, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<short, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<short, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void mulScalar<int, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<int, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<int, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<int, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<int, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<int, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<int, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void mulScalar<float, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<float, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void mulScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<double, double, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<double, double, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<double, double, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void mulScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void mulScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// divMat
+
+namespace
+{
+    struct Div_8uc4_32f : binary_function<uint, float, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, float b) const
+        {
+            uint res = 0;
+
+            if (b != 0)
+            {
+                b = 1.0f / b;
+                res |= (saturate_cast<uchar>((0xffu & (a      )) * b)      );
+                res |= (saturate_cast<uchar>((0xffu & (a >>  8)) * b) <<  8);
+                res |= (saturate_cast<uchar>((0xffu & (a >> 16)) * b) << 16);
+                res |= (saturate_cast<uchar>((0xffu & (a >> 24)) * b) << 24);
+            }
+
+            return res;
+        }
+    };
+
+    struct Div_16sc4_32f : binary_function<short4, float, short4>
     {
         __device__ __forceinline__ short4 operator ()(short4 a, float b) const
         {
@@ -757,425 +1200,905 @@ namespace cv { namespace gpu { namespace device
         }
     };
 
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(divide_16sc4_32f)
+    template <typename T, typename D> struct Div : binary_function<T, T, D>
+    {
+        __device__ __forceinline__ D operator ()(T a, T b) const
+        {
+            return b != 0 ? saturate_cast<D>(a / b) : 0;
+        }
+
+        __device__ __forceinline__ Div() {}
+        __device__ __forceinline__ Div(const Div& other) {}
+    };
+    template <typename T> struct Div<T, float> : binary_function<T, T, float>
+    {
+        __device__ __forceinline__ float operator ()(T a, T b) const
+        {
+            return b != 0 ? static_cast<float>(a) / b : 0;
+        }
+
+        __device__ __forceinline__ Div() {}
+        __device__ __forceinline__ Div(const Div& other) {}
+    };
+    template <typename T> struct Div<T, double> : binary_function<T, T, double>
+    {
+        __device__ __forceinline__ double operator ()(T a, T b) const
+        {
+            return b != 0 ? static_cast<double>(a) / b : 0;
+        }
+
+        __device__ __forceinline__ Div() {}
+        __device__ __forceinline__ Div(const Div& other) {}
+    };
+
+    template <typename T, typename S, typename D> struct DivScale : binary_function<T, T, D>
+    {
+        S scale;
+
+        explicit DivScale(S scale_) : scale(scale_) {}
+
+        __device__ __forceinline__ D operator ()(T a, T b) const
+        {
+            return b != 0 ? saturate_cast<D>(scale * a / b) : 0;
+        }
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(Div_8uc4_32f)
     {
         enum { smart_block_dim_x = 8 };
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 8 };
     };
 
-    void divide_gpu(const PtrStepSz<short4>& src1, const PtrStepSzf& src2, const PtrStepSz<short4>& dst, cudaStream_t stream)
+    template <> struct TransformFunctorTraits< Div<ushort, ushort> > : DefaultTransformFunctorTraits< Div<ushort, ushort> >
     {
-        cv::gpu::device::transform(static_cast< PtrStepSz<short4> >(src1), src2, static_cast< PtrStepSz<short4> >(dst), divide_16sc4_32f(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Div<short, short> > : DefaultTransformFunctorTraits< Div<short, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Div<int, int> > : DefaultTransformFunctorTraits< Div<int, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Div<float, float> > : DefaultTransformFunctorTraits< Div<float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct TransformFunctorTraits< DivScale<ushort, float, ushort> > : DefaultTransformFunctorTraits< DivScale<ushort, float, ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< DivScale<short, float, short> > : DefaultTransformFunctorTraits< DivScale<short, float, short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< DivScale<int, float, int> > : DefaultTransformFunctorTraits< DivScale<int, float, int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< DivScale<float, float, float> > : DefaultTransformFunctorTraits< DivScale<float, float, float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    void divMat_8uc4_32f(PtrStepSz<uint> src1, PtrStepSzf src2, PtrStepSz<uint> dst, cudaStream_t stream)
+    {
+        transform(src1, src2, dst, Div_8uc4_32f(), WithOutMask(), stream);
     }
 
-    template <typename T, typename D> struct Divide : binary_function<T, T, D>
+    void divMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream)
     {
-        Divide(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a, T b) const
+        transform(src1, src2, dst, Div_16sc4_32f(), WithOutMask(), stream);
+    }
+
+    template <typename T, typename S, typename D>
+    void divMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream)
+    {
+        if (scale == 1)
         {
-            return b != 0 ? saturate_cast<D>(a * scale / b) : 0;
+            Div<T, D> op;
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+        }
+        else
+        {
+            DivScale<T, S, D> op(static_cast<S>(scale));
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
         }
-        const double scale;
-    };
-
-    template <> struct TransformFunctorTraits< Divide<ushort, ushort> > : DefaultTransformFunctorTraits< Divide<ushort, ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Divide<short, short> > : DefaultTransformFunctorTraits< Divide<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Divide<int, int> > : DefaultTransformFunctorTraits< Divide<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Divide<float, float> > : DefaultTransformFunctorTraits< Divide<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-
-    template <typename T, typename D> void divide_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream)
-    {
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        Divide<T, D> op(scale);
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
     }
 
-    template void divide_gpu<uchar, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<uchar, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<schar, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<schar, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<ushort, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divMat<ushort, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<ushort, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<ushort, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<ushort, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<ushort, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<ushort, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<ushort, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<short, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divMat<short, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<short, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<short, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<short, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<short, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<short, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<short, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<int, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divMat<int, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<int, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<int, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<int, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<int, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<int, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<int, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<float, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divMat<float, float, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<float, float, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<float, float, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<float, float, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<float, float, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<float, float, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<float, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
 
-    //template void divide_gpu<double, uchar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, short >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, float >(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<double, double>(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    //template void divMat<double, double, float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+    template void divMat<double, double, double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+}
 
-    template <typename T, typename D> struct DivideScalar : unary_function<T, D>
+//////////////////////////////////////////////////////////////////////////
+// divScalar
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void divScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
     {
-        DivideScalar(double val_, double scale_) : val(val_), scale(scale_) {}
+        MulScalar<T, S, D> op(static_cast<S>(1.0 / val));
+        transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
+    }
+
+    template void divScalar<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<uchar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    template void divScalar<schar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<schar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void divScalar<ushort, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<ushort, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<ushort, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<ushort, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<ushort, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<ushort, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<ushort, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void divScalar<short, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<short, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<short, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<short, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<short, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<short, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<short, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void divScalar<int, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<int, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<int, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<int, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<int, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<int, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<int, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void divScalar<float, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<float, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+
+    //template void divScalar<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<double, double, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<double, double, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<double, double, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divScalar<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divScalar<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// divInv
+
+namespace
+{
+    template <typename T, typename S, typename D> struct DivInv : unary_function<T, D>
+    {
+        S val;
+
+        explicit DivInv(double val_) : val(val_) {}
+
         __device__ __forceinline__ D operator ()(T a) const
         {
-            return saturate_cast<D>(scale * a / val);
+            return a != 0 ? saturate_cast<D>(val / a) : 0;
         }
-        const double val;
-        const double scale;
     };
+}
 
-    template <> struct TransformFunctorTraits< DivideScalar<ushort, ushort> > : DefaultTransformFunctorTraits< DivideScalar<ushort, ushort> >
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< DivInv<ushort, float, ushort> > : DefaultTransformFunctorTraits< DivInv<ushort, float, ushort> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< DivideScalar<short, short> > : DefaultTransformFunctorTraits< DivideScalar<short, short> >
+    template <> struct TransformFunctorTraits< DivInv<short, float, short> > : DefaultTransformFunctorTraits< DivInv<short, float, short> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< DivideScalar<int, int> > : DefaultTransformFunctorTraits< DivideScalar<int, int> >
+    template <> struct TransformFunctorTraits< DivInv<int, float, int> > : DefaultTransformFunctorTraits< DivInv<int, float, int> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< DivideScalar<float, float> > : DefaultTransformFunctorTraits< DivideScalar<float, float> >
+    template <> struct TransformFunctorTraits< DivInv<float, float, float> > : DefaultTransformFunctorTraits< DivInv<float, float, float> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
+}}}
 
-    template <typename T, typename D> void divide_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream)
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void divInv(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        cudaSafeCall( cudaSetDoubleForDevice(&scale) );
-        DivideScalar<T, D> op(val, scale);
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
+        DivInv<T, S, D> op(static_cast<S>(val));
+        transform((PtrStepSz<T>) src1, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
     }
 
-    template void divide_gpu<uchar, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    template void divInv<uchar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<uchar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<schar, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    template void divInv<schar, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<schar, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<ushort, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divInv<ushort, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<ushort, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<ushort, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<ushort, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<ushort, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<ushort, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<ushort, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<short, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<short, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divInv<short, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<short, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<short, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<short, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<short, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<short, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<short, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<int, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<int, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<int, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divInv<int, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<int, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<int, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<int, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<int, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<int, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<int, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<float, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<float, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divInv<float, float, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<float, float, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<float, float, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<float, float, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<float, float, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<float, float, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<float, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 
-    //template void divide_gpu<double, uchar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, short >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    //template void divide_gpu<double, float >(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-    template void divide_gpu<double, double>(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    //template void divInv<double, double, uchar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<double, double, schar>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<double, double, ushort>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<double, double, short>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<double, double, int>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    //template void divInv<double, double, float>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void divInv<double, double, double>(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+}
 
-    template <typename T, typename D> struct Reciprocal : unary_function<T, D>
+//////////////////////////////////////////////////////////////////////////
+// absDiffMat
+
+namespace
+{
+    template <typename T, typename D> struct VAbsDiff4;
+    template <> struct VAbsDiff4<uint, uint> : binary_function<uint, uint, uint>
     {
-        Reciprocal(double scale_) : scale(scale_) {}
-        __device__ __forceinline__ D operator ()(T a) const
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
         {
-            return a != 0 ? saturate_cast<D>(scale / a) : 0;
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vabsdiff4.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vabsdiff.u32.u32.u32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.u32.u32.u32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.u32.u32.u32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.u32.u32.u32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
         }
-        const double scale;
+
+        __device__ __forceinline__ VAbsDiff4() {}
+        __device__ __forceinline__ VAbsDiff4(const VAbsDiff4<uint, uint>& other) {}
+    };
+    template <> struct VAbsDiff4<int, int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vabsdiff4.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vabsdiff.s32.s32.s32.sat %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.s32.s32.s32.sat %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.s32.s32.s32.sat %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.s32.s32.s32.sat %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAbsDiff4() {}
+        __device__ __forceinline__ VAbsDiff4(const VAbsDiff4<int, int>& other) {}
     };
 
-    template <> struct TransformFunctorTraits< Reciprocal<ushort, ushort> > : DefaultTransformFunctorTraits< Reciprocal<ushort, ushort> >
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct VAbsDiff2;
+    template <> struct VAbsDiff2<uint, uint> : binary_function<uint, uint, uint>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
+        {
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vabsdiff2.u32.u32.u32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vabsdiff.u32.u32.u32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.u32.u32.u32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAbsDiff2() {}
+        __device__ __forceinline__ VAbsDiff2(const VAbsDiff2<uint, uint>& other) {}
     };
-    template <> struct TransformFunctorTraits< Reciprocal<short, short> > : DefaultTransformFunctorTraits< Reciprocal<short, short> >
+    template <> struct VAbsDiff2<int, int> : binary_function<int, int, int>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Reciprocal<int, int> > : DefaultTransformFunctorTraits< Reciprocal<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Reciprocal<float, float> > : DefaultTransformFunctorTraits< Reciprocal<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vabsdiff2.s32.s32.s32.sat %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vabsdiff.s32.s32.s32.sat %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vabsdiff.s32.s32.s32.sat %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VAbsDiff2() {}
+        __device__ __forceinline__ VAbsDiff2(const VAbsDiff2<int, int>& other) {}
     };
 
-    template <typename T, typename D> void divide_gpu(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream)
+    ////////////////////////////////////
+
+    __device__ __forceinline__ int _abs(int a)
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&scalar) );
-        Reciprocal<T, D> op(scalar);
-        cv::gpu::device::transform((PtrStepSz<T>)src2, (PtrStepSz<D>)dst, op, WithOutMask(), stream);
+        return ::abs(a);
+    }
+    __device__ __forceinline__ float _abs(float a)
+    {
+        return ::fabsf(a);
+    }
+    __device__ __forceinline__ double _abs(double a)
+    {
+        return ::fabs(a);
     }
 
-    template void divide_gpu<uchar, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<uchar, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<uchar, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<schar, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<schar, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<ushort, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<ushort, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<ushort, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<ushort, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<short, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<short, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<short, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<short, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<short, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<short, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<short, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<int, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<int, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<int, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<int, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<int, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<int, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<int, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<float, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<float, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<float, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<float, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<float, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<float, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<float, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //template void divide_gpu<double, uchar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<double, schar >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<double, ushort>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<double, short >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<double, int   >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    //template void divide_gpu<double, float >(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-    template void divide_gpu<double, double>(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-
-    //////////////////////////////////////////////////////////////////////////
-    // absdiff
-
-    template <typename T> struct Absdiff : binary_function<T, T, T>
+    template <typename T> struct AbsDiffMat : binary_function<T, T, T>
     {
-        static __device__ __forceinline__ int abs(int a)
-        {
-            return ::abs(a);
-        }
-        static __device__ __forceinline__ float abs(float a)
-        {
-            return ::fabsf(a);
-        }
-        static __device__ __forceinline__ double abs(double a)
-        {
-            return ::fabs(a);
-        }
-
         __device__ __forceinline__ T operator ()(T a, T b) const
         {
-            return saturate_cast<T>(::abs(a - b));
+            return saturate_cast<T>(_abs(a - b));
         }
+
+        __device__ __forceinline__ AbsDiffMat() {}
+        __device__ __forceinline__ AbsDiffMat(const AbsDiffMat& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff4<T, D> > : DefaultTransformFunctorTraits< VAbsDiff4<T, D> >
+    {
+        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< Absdiff<ushort> > : DefaultTransformFunctorTraits< Absdiff<ushort> >
+    ////////////////////////////////////
+
+    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff2<T, D> > : DefaultTransformFunctorTraits< VAbsDiff4<T, D> >
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Absdiff<short> > : DefaultTransformFunctorTraits< Absdiff<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Absdiff<int> > : DefaultTransformFunctorTraits< Absdiff<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Absdiff<float> > : DefaultTransformFunctorTraits< Absdiff<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
+        enum { smart_shift = 2 };
     };
 
-    template <typename T> void absdiff_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    ////////////////////////////////////
+
+    template <> struct TransformFunctorTraits< AbsDiffMat<ushort> > : DefaultTransformFunctorTraits< AbsDiffMat<ushort> >
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<T>)dst, Absdiff<T>(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AbsDiffMat<short> > : DefaultTransformFunctorTraits< AbsDiffMat<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AbsDiffMat<int> > : DefaultTransformFunctorTraits< AbsDiffMat<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< AbsDiffMat<float> > : DefaultTransformFunctorTraits< AbsDiffMat<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void vabsDiff4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VAbsDiff4<T, T>(), WithOutMask(), stream);
     }
 
-    //template void absdiff_gpu<uchar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<schar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    //template void absdiff_gpu<ushort>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<short >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<int   >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    //template void absdiff_gpu<float >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<double>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vabsDiff4<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vabsDiff4<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template <typename T> struct AbsdiffScalar : unary_function<T, T>
+    template <typename T>
+    void vabsDiff2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        AbsdiffScalar(double val_) : val(val_) {}
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VAbsDiff2<T, T>(), WithOutMask(), stream);
+    }
+
+    template void vabsDiff2<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vabsDiff2<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T>
+    void absDiffMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, AbsDiffMat<T>(), WithOutMask(), stream);
+    }
+
+    template void absDiffMat<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<schar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<short>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<float>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// absDiffScalar
+
+namespace
+{
+    template <typename T, typename S> struct AbsDiffScalar : unary_function<T, T>
+    {
+        S val;
+
+        explicit AbsDiffScalar(S val_) : val(val_) {}
+
         __device__ __forceinline__ T operator ()(T a) const
         {
-            return saturate_cast<T>(::fabs(a - val));
+            abs_func<S> f;
+            return saturate_cast<T>(f(a - val));
         }
-        double val;
     };
+}
 
-    template <> struct TransformFunctorTraits< AbsdiffScalar<ushort> > : DefaultTransformFunctorTraits< AbsdiffScalar<ushort> >
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< AbsDiffScalar<ushort, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<ushort, float>  >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<short> > : DefaultTransformFunctorTraits< AbsdiffScalar<short> >
+    template <> struct TransformFunctorTraits< AbsDiffScalar<short, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<short, float> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<int> > : DefaultTransformFunctorTraits< AbsdiffScalar<int> >
+    template <> struct TransformFunctorTraits< AbsDiffScalar<int, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<int, float> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AbsdiffScalar<float> > : DefaultTransformFunctorTraits< AbsdiffScalar<float> >
+    template <> struct TransformFunctorTraits< AbsDiffScalar<float, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<float, float> >
     {
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
+}}}
 
-    template <typename T> void absdiff_gpu(const PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
+namespace arithm
+{
+    template <typename T, typename S>
+    void absDiffScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
     {
-        cudaSafeCall( cudaSetDoubleForDevice(&val) );
-        AbsdiffScalar<T> op(val);
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)dst, op, WithOutMask(), stream);
+        AbsDiffScalar<T, S> op(static_cast<S>(val));
+
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, op, WithOutMask(), stream);
     }
 
-    //template void absdiff_gpu<uchar >(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<schar >(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    //template void absdiff_gpu<ushort>(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<short >(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<int   >(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    //template void absdiff_gpu<float >(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
-    template void absdiff_gpu<double>(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<uchar, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<schar, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<ushort, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<short, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<int, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<float, float>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void absDiffScalar<double, double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////////////////
-    // Compare
+//////////////////////////////////////////////////////////////////////////
+// absMat
 
-    template <template <typename> class Op, typename T>
-    struct Compare: binary_function<T, T, uchar>
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< abs_func<ushort> > : DefaultTransformFunctorTraits< abs_func<ushort> >
     {
-        __device__ __forceinline__ uchar operator()(T src1, T src2) const
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< abs_func<short> > : DefaultTransformFunctorTraits< abs_func<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< abs_func<int> > : DefaultTransformFunctorTraits< abs_func<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< abs_func<float> > : DefaultTransformFunctorTraits< abs_func<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void absMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, abs_func<T>(), WithOutMask(), stream);
+    }
+
+    template void absMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void absMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// sqrMat
+
+namespace
+{
+    template <typename T> struct Sqr : unary_function<T, T>
+    {
+        __device__ __forceinline__ T operator ()(T x) const
+        {
+            return saturate_cast<T>(x * x);
+        }
+
+        __device__ __forceinline__ Sqr() {}
+        __device__ __forceinline__ Sqr(const Sqr& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< Sqr<ushort> > : DefaultTransformFunctorTraits< Sqr<ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Sqr<short> > : DefaultTransformFunctorTraits< Sqr<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Sqr<int> > : DefaultTransformFunctorTraits< Sqr<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Sqr<float> > : DefaultTransformFunctorTraits< Sqr<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void sqrMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Sqr<T>(), WithOutMask(), stream);
+    }
+
+    template void sqrMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// sqrtMat
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< sqrt_func<uchar> > : DefaultTransformFunctorTraits< sqrt_func<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< sqrt_func<schar> > : DefaultTransformFunctorTraits< sqrt_func<schar> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< sqrt_func<ushort> > : DefaultTransformFunctorTraits< sqrt_func<ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< sqrt_func<short> > : DefaultTransformFunctorTraits< sqrt_func<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< sqrt_func<int> > : DefaultTransformFunctorTraits< sqrt_func<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< sqrt_func<float> > : DefaultTransformFunctorTraits< sqrt_func<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void sqrtMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, sqrt_func<T>(), WithOutMask(), stream);
+    }
+
+    template void sqrtMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void sqrtMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// logMat
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< log_func<uchar> > : DefaultTransformFunctorTraits< log_func<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< log_func<schar> > : DefaultTransformFunctorTraits< log_func<schar> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< log_func<ushort> > : DefaultTransformFunctorTraits< log_func<ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< log_func<short> > : DefaultTransformFunctorTraits< log_func<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< log_func<int> > : DefaultTransformFunctorTraits< log_func<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< log_func<float> > : DefaultTransformFunctorTraits< log_func<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void logMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, log_func<T>(), WithOutMask(), stream);
+    }
+
+    template void logMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void logMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// expMat
+
+namespace
+{
+    template <typename T> struct Exp : unary_function<T, T>
+    {
+        __device__ __forceinline__ T operator ()(T x) const
+        {
+            exp_func<T> f;
+            return saturate_cast<T>(f(x));
+        }
+
+        __device__ __forceinline__ Exp() {}
+        __device__ __forceinline__ Exp(const Exp& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< Exp<ushort> > : DefaultTransformFunctorTraits< Exp<ushort> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Exp<short> > : DefaultTransformFunctorTraits< Exp<short> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Exp<int> > : DefaultTransformFunctorTraits< Exp<int> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< Exp<float> > : DefaultTransformFunctorTraits< Exp<float> >
+    {
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T>
+    void expMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, Exp<T>(), WithOutMask(), stream);
+    }
+
+    template void expMat<uchar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<schar>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<ushort>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<short>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<int>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<float>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    template void expMat<double>(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// cmpMat
+
+namespace
+{
+    template <template <typename> class Op, typename T>
+    struct Cmp: binary_function<T, T, uchar>
+    {
+        __device__ __forceinline__ uchar operator()(T a, T b) const
         {
             Op<T> op;
-            return static_cast<uchar>(static_cast<int>(op(src1, src2)) * 255);
+            return -op(a, b);
         }
     };
+}
 
-#define IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(op, type, block_dim_y, shift) \
-    template <> struct TransformFunctorTraits< Compare<op, type> > : DefaultTransformFunctorTraits< Compare<op, type> > \
-    { \
-        enum { smart_block_dim_y = block_dim_y }; \
-        enum { smart_shift = shift }; \
-    };
+namespace cv { namespace gpu { namespace device
+{
+    #define IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(op, type, block_dim_y, shift) \
+        template <> struct TransformFunctorTraits< Cmp<op, type> > : DefaultTransformFunctorTraits< Cmp<op, type> > \
+        { \
+            enum { smart_block_dim_y = block_dim_y }; \
+            enum { smart_shift = shift }; \
+        };
 
     IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, int, 8, 4)
     IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, float, 8, 4)
@@ -1190,132 +2113,136 @@ namespace cv { namespace gpu { namespace device
     IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, int, 8, 4)
     IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, float, 8, 4)
 
-#undef IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS
+    #undef IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS
+}}}
 
-    template <template <typename> class Op, typename T> void compare(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+namespace arithm
+{
+    template <template <typename> class Op, typename T>
+    void cmpMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        Compare<Op, T> op;
-        cv::gpu::device::transform(static_cast< PtrStepSz<T> >(src1), static_cast< PtrStepSz<T> >(src2), dst, op, WithOutMask(), stream);
+        Cmp<Op, T> op;
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, dst, op, WithOutMask(), stream);
     }
 
-    template <typename T> void compare_eq(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpMatEq(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        compare<equal_to, T>(src1, src2, dst, stream);
+        cmpMat<equal_to, T>(src1, src2, dst, stream);
     }
-    template <typename T> void compare_ne(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpMatNe(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        compare<not_equal_to, T>(src1, src2, dst, stream);
+        cmpMat<not_equal_to, T>(src1, src2, dst, stream);
     }
-    template <typename T> void compare_lt(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpMatLt(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        compare<less, T>(src1, src2, dst, stream);
+        cmpMat<less, T>(src1, src2, dst, stream);
     }
-    template <typename T> void compare_le(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpMatLe(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        compare<less_equal, T>(src1, src2, dst, stream);
+        cmpMat<less_equal, T>(src1, src2, dst, stream);
     }
 
-    template void compare_eq<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatEq<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_ne<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatNe<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_lt<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLt<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_le<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void cmpMatLe<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+}
 
+//////////////////////////////////////////////////////////////////////////////////////
+// cmpScalar
+
+namespace
+{
 #define TYPE_VEC(type, cn) typename TypeVec<type, cn>::vec_type
 
-    template <template <typename> class Op, typename T, int cn> struct CompareScalar;
+    template <template <typename> class Op, typename T, int cn> struct CmpScalar;
     template <template <typename> class Op, typename T>
-    struct CompareScalar<Op, T, 1>: unary_function<T, uchar>
+    struct CmpScalar<Op, T, 1> : unary_function<T, uchar>
     {
         const T val;
 
-        __host__ explicit CompareScalar(T val_) : val(val_) {}
+        __host__ explicit CmpScalar(T val_) : val(val_) {}
 
         __device__ __forceinline__ uchar operator()(T src) const
         {
-            Op<T> op;
-            return static_cast<uchar>(static_cast<int>(op(src, val)) * 255);
+            Cmp<Op, T> op;
+            return op(src, val);
         }
     };
     template <template <typename> class Op, typename T>
-    struct CompareScalar<Op, T, 2>: unary_function<TYPE_VEC(T, 2), TYPE_VEC(uchar, 2)>
+    struct CmpScalar<Op, T, 2> : unary_function<TYPE_VEC(T, 2), TYPE_VEC(uchar, 2)>
     {
         const TYPE_VEC(T, 2) val;
 
-        __host__ explicit CompareScalar(TYPE_VEC(T, 2) val_) : val(val_) {}
+        __host__ explicit CmpScalar(TYPE_VEC(T, 2) val_) : val(val_) {}
 
         __device__ __forceinline__ TYPE_VEC(uchar, 2) operator()(const TYPE_VEC(T, 2) & src) const
         {
-            Op<T> op;
-            return VecTraits<TYPE_VEC(uchar, 2)>::make(
-                        static_cast<uchar>(static_cast<int>(op(src.x, val.x)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.y, val.y)) * 255));
+            Cmp<Op, T> op;
+            return VecTraits<TYPE_VEC(uchar, 2)>::make(op(src.x, val.x), op(src.y, val.y));
         }
     };
     template <template <typename> class Op, typename T>
-    struct CompareScalar<Op, T, 3>: unary_function<TYPE_VEC(T, 3), TYPE_VEC(uchar, 3)>
+    struct CmpScalar<Op, T, 3> : unary_function<TYPE_VEC(T, 3), TYPE_VEC(uchar, 3)>
     {
         const TYPE_VEC(T, 3) val;
 
-        __host__ explicit CompareScalar(TYPE_VEC(T, 3) val_) : val(val_) {}
+        __host__ explicit CmpScalar(TYPE_VEC(T, 3) val_) : val(val_) {}
 
         __device__ __forceinline__ TYPE_VEC(uchar, 3) operator()(const TYPE_VEC(T, 3) & src) const
         {
-            Op<T> op;
-            return VecTraits<TYPE_VEC(uchar, 3)>::make(
-                        static_cast<uchar>(static_cast<int>(op(src.x, val.x)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.y, val.y)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.z, val.z)) * 255));
+            Cmp<Op, T> op;
+            return VecTraits<TYPE_VEC(uchar, 3)>::make(op(src.x, val.x), op(src.y, val.y), op(src.z, val.z));
         }
     };
     template <template <typename> class Op, typename T>
-    struct CompareScalar<Op, T, 4>: unary_function<TYPE_VEC(T, 4), TYPE_VEC(uchar, 4)>
+    struct CmpScalar<Op, T, 4> : unary_function<TYPE_VEC(T, 4), TYPE_VEC(uchar, 4)>
     {
         const TYPE_VEC(T, 4) val;
 
-        __host__ explicit CompareScalar(TYPE_VEC(T, 4) val_) : val(val_) {}
+        __host__ explicit CmpScalar(TYPE_VEC(T, 4) val_) : val(val_) {}
 
         __device__ __forceinline__ TYPE_VEC(uchar, 4) operator()(const TYPE_VEC(T, 4) & src) const
         {
-            Op<T> op;
-            return VecTraits<TYPE_VEC(uchar, 4)>::make(
-                        static_cast<uchar>(static_cast<int>(op(src.x, val.x)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.y, val.y)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.z, val.z)) * 255),
-                        static_cast<uchar>(static_cast<int>(op(src.w, val.w)) * 255));
+            Cmp<Op, T> op;
+            return VecTraits<TYPE_VEC(uchar, 4)>::make(op(src.x, val.x), op(src.y, val.y), op(src.z, val.z), op(src.w, val.w));
         }
     };
 
 #undef TYPE_VEC
+}
 
+namespace cv { namespace gpu { namespace device
+{
 #define IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(op, type, block_dim_y, shift) \
-    template <> struct TransformFunctorTraits< CompareScalar<op, type, 1> > : DefaultTransformFunctorTraits< CompareScalar<op, type, 1> > \
+    template <> struct TransformFunctorTraits< CmpScalar<op, type, 1> > : DefaultTransformFunctorTraits< CmpScalar<op, type, 1> > \
     { \
         enum { smart_block_dim_y = block_dim_y }; \
         enum { smart_shift = shift }; \
@@ -1335,8 +2262,12 @@ namespace cv { namespace gpu { namespace device
     IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, float, 8, 4)
 
 #undef IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS
+}}}
 
-    template <template <typename> class Op, typename T, int cn> void compare(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream)
+namespace arithm
+{
+    template <template <typename> class Op, typename T, int cn>
+    void cmpScalar(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef typename TypeVec<T, cn>::vec_type src_t;
         typedef typename TypeVec<uchar, cn>::vec_type dst_t;
@@ -1344,505 +2275,721 @@ namespace cv { namespace gpu { namespace device
         T sval[] = {static_cast<T>(val[0]), static_cast<T>(val[1]), static_cast<T>(val[2]), static_cast<T>(val[3])};
         src_t val1 = VecTraits<src_t>::make(sval);
 
-        CompareScalar<Op, T, cn> op(val1);
-
-        cv::gpu::device::transform(static_cast< PtrStepSz<src_t> >(src), static_cast< PtrStepSz<dst_t> >(dst), op, WithOutMask(), stream);
+        CmpScalar<Op, T, cn> op(val1);
+        transform((PtrStepSz<src_t>) src, (PtrStepSz<dst_t>) dst, op, WithOutMask(), stream);
     }
 
-    template <typename T> void compare_eq(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarEq(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<equal_to, T, 1>,
-            compare<equal_to, T, 2>,
-            compare<equal_to, T, 3>,
-            compare<equal_to, T, 4>
+            cmpScalar<equal_to, T, 1>,
+            cmpScalar<equal_to, T, 2>,
+            cmpScalar<equal_to, T, 3>,
+            cmpScalar<equal_to, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
-    template <typename T> void compare_ne(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarNe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<not_equal_to, T, 1>,
-            compare<not_equal_to, T, 2>,
-            compare<not_equal_to, T, 3>,
-            compare<not_equal_to, T, 4>
+            cmpScalar<not_equal_to, T, 1>,
+            cmpScalar<not_equal_to, T, 2>,
+            cmpScalar<not_equal_to, T, 3>,
+            cmpScalar<not_equal_to, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
-    template <typename T> void compare_lt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarLt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<less, T, 1>,
-            compare<less, T, 2>,
-            compare<less, T, 3>,
-            compare<less, T, 4>
+            cmpScalar<less, T, 1>,
+            cmpScalar<less, T, 2>,
+            cmpScalar<less, T, 3>,
+            cmpScalar<less, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
-    template <typename T> void compare_le(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarLe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<less_equal, T, 1>,
-            compare<less_equal, T, 2>,
-            compare<less_equal, T, 3>,
-            compare<less_equal, T, 4>
+            cmpScalar<less_equal, T, 1>,
+            cmpScalar<less_equal, T, 2>,
+            cmpScalar<less_equal, T, 3>,
+            cmpScalar<less_equal, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
-    template <typename T> void compare_gt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarGt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<greater, T, 1>,
-            compare<greater, T, 2>,
-            compare<greater, T, 3>,
-            compare<greater, T, 4>
+            cmpScalar<greater, T, 1>,
+            cmpScalar<greater, T, 2>,
+            cmpScalar<greater, T, 3>,
+            cmpScalar<greater, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
-    template <typename T> void compare_ge(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void cmpScalarGe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream)
     {
         typedef void (*func_t)(PtrStepSzb src, double val[4], PtrStepSzb dst, cudaStream_t stream);
         static const func_t funcs[] =
         {
             0,
-            compare<greater_equal, T, 1>,
-            compare<greater_equal, T, 2>,
-            compare<greater_equal, T, 3>,
-            compare<greater_equal, T, 4>
+            cmpScalar<greater_equal, T, 1>,
+            cmpScalar<greater_equal, T, 2>,
+            cmpScalar<greater_equal, T, 3>,
+            cmpScalar<greater_equal, T, 4>
         };
 
         funcs[cn](src, val, dst, stream);
     }
 
-    template void compare_eq<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_eq<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarEq<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_ne<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ne<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarNe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_lt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_lt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_le<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_le<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarLe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_gt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_gt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGt<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 
-    template void compare_ge<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template void compare_ge<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<uchar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<schar >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<ushort>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<short >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<int   >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<float >(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template void cmpScalarGe<double>(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////
-    // Unary bitwise logical matrix operations
+//////////////////////////////////////////////////////////////////////////////////////
+// bitMat
 
-    enum { UN_OP_NOT };
-
-    template <typename T, int opid>
-    struct UnOp;
-
-    template <typename T>
-    struct UnOp<T, UN_OP_NOT>
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< bit_not<uchar> > : DefaultTransformFunctorTraits< bit_not<uchar> >
     {
-        static __device__ __forceinline__ T call(T v) { return ~v; }
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_not<ushort> > : DefaultTransformFunctorTraits< bit_not<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_not<uint> > : DefaultTransformFunctorTraits< bit_not<uint> >
+    {
+        enum { smart_shift = 2 };
     };
 
-
-    template <int opid>
-    __global__ void bitwiseUnOpKernel(int rows, int width, const PtrStepb src, PtrStepb dst)
+    template <> struct TransformFunctorTraits< bit_and<uchar> > : DefaultTransformFunctorTraits< bit_and<uchar> >
     {
-        const int x = (blockDim.x * blockIdx.x + threadIdx.x) * 4;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_and<ushort> > : DefaultTransformFunctorTraits< bit_and<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_and<uint> > : DefaultTransformFunctorTraits< bit_and<uint> >
+    {
+        enum { smart_shift = 2 };
+    };
 
-        if (y < rows)
+    template <> struct TransformFunctorTraits< bit_or<uchar> > : DefaultTransformFunctorTraits< bit_or<uchar> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_or<ushort> > : DefaultTransformFunctorTraits< bit_or<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_or<uint> > : DefaultTransformFunctorTraits< bit_or<uint> >
+    {
+        enum { smart_shift = 2 };
+    };
+
+    template <> struct TransformFunctorTraits< bit_xor<uchar> > : DefaultTransformFunctorTraits< bit_xor<uchar> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_xor<ushort> > : DefaultTransformFunctorTraits< bit_xor<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< bit_xor<uint> > : DefaultTransformFunctorTraits< bit_xor<uint> >
+    {
+        enum { smart_shift = 2 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T> void bitMatNot(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, bit_not<T>(), WithOutMask(), stream);
+    }
+
+    template <typename T> void bitMatAnd(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_and<T>(), WithOutMask(), stream);
+    }
+
+    template <typename T> void bitMatOr(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_or<T>(), WithOutMask(), stream);
+    }
+
+    template <typename T> void bitMatXor(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream)
+    {
+        if (mask.data)
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), mask, stream);
+        else
+            transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, bit_xor<T>(), WithOutMask(), stream);
+    }
+
+    template void bitMatNot<uchar>(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatNot<ushort>(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatNot<uint>(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    template void bitMatAnd<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatAnd<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatAnd<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    template void bitMatOr<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatOr<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatOr<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+
+    template void bitMatXor<uchar>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatXor<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template void bitMatXor<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////
+// bitScalar
+
+namespace cv { namespace gpu { namespace device
+{
+    template <> struct TransformFunctorTraits< binder2nd< bit_and<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<uchar> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_and<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<ushort> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_and<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<uint> > >
+    {
+        enum { smart_shift = 2 };
+    };
+
+    template <> struct TransformFunctorTraits< binder2nd< bit_or<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<uchar> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_or<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<ushort> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_or<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<uint> > >
+    {
+        enum { smart_shift = 2 };
+    };
+
+    template <> struct TransformFunctorTraits< binder2nd< bit_xor<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<uchar> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_xor<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<ushort> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< bit_xor<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<uint> > >
+    {
+        enum { smart_shift = 2 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T> void bitScalarAnd(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_and<T>(), src2), WithOutMask(), stream);
+    }
+
+    template <typename T> void bitScalarOr(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_or<T>(), src2), WithOutMask(), stream);
+    }
+
+    template <typename T> void bitScalarXor(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(bit_xor<T>(), src2), WithOutMask(), stream);
+    }
+
+    template void bitScalarAnd<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarAnd<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarAnd<uint>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template void bitScalarOr<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarOr<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarOr<uint>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template void bitScalarXor<uchar>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarXor<ushort>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+    template void bitScalarXor<uint>(PtrStepSzb src1, uint src2, PtrStepSzb dst, cudaStream_t stream);
+}
+
+//////////////////////////////////////////////////////////////////////////
+// min
+
+namespace
+{
+    template <typename T> struct VMin4;
+    template <> struct VMin4<uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
         {
-            uchar* dst_ptr = dst.ptr(y) + x;
-            const uchar* src_ptr = src.ptr(y) + x;
-            if (x + sizeof(uint) - 1 < width)
-            {
-                *(uint*)dst_ptr = UnOp<uint, opid>::call(*(uint*)src_ptr);
-            }
-            else
-            {
-                const uchar* src_end = src.ptr(y) + width;
-                while (src_ptr < src_end)
-                {
-                    *dst_ptr++ = UnOp<uchar, opid>::call(*src_ptr++);
-                }
-            }
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vmin4.u32.u32.u32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmin.u32.u32.u32 %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.u32.u32.u32 %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.u32.u32.u32 %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.u32.u32.u32 %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
         }
-    }
 
-
-    template <int opid>
-    void bitwiseUnOp(int rows, int width, const PtrStepb src, PtrStepb dst,
-                     cudaStream_t stream)
+        __device__ __forceinline__ VMin4() {}
+        __device__ __forceinline__ VMin4(const VMin4& other) {}
+    };
+    template <> struct VMin4<int> : binary_function<int, int, int>
     {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(width, threads.x * sizeof(uint)),
-                  divUp(rows, threads.y));
-
-        bitwiseUnOpKernel<opid><<<grid, threads>>>(rows, width, src, dst);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-
-    template <typename T, int opid>
-    __global__ void bitwiseUnOpKernel(int rows, int cols, int cn, const PtrStepb src,
-                                      const PtrStepb mask, PtrStepb dst)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < cols && y < rows && mask.ptr(y)[x / cn])
+        __device__ __forceinline__ int operator ()(int a, int b) const
         {
-            T* dst_row = (T*)dst.ptr(y);
-            const T* src_row = (const T*)src.ptr(y);
+            int res = 0;
 
-            dst_row[x] = UnOp<T, opid>::call(src_row[x]);
+        #if __CUDA_ARCH__ >= 300
+            asm("vmin4.s32.s32.s32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmin.s32.s32.s32 %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.s32.s32.s32 %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.s32.s32.s32 %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.s32.s32.s32 %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
         }
-    }
 
-
-    template <typename T, int opid>
-    void bitwiseUnOp(int rows, int cols, int cn, const PtrStepb src,
-                     const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
-    {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
-
-        bitwiseUnOpKernel<T, opid><<<grid, threads>>>(rows, cols, cn, src, mask, dst);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-
-    void bitwiseNotCaller(int rows, int cols, size_t elem_size1, int cn,
-                          const PtrStepb src, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseUnOp<UN_OP_NOT>(rows, static_cast<int>(cols * elem_size1 * cn), src, dst, stream);
-    }
-
-
-    template <typename T>
-    void bitwiseMaskNotCaller(int rows, int cols, int cn, const PtrStepb src,
-                              const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseUnOp<T, UN_OP_NOT>(rows, cols * cn, cn, src, mask, dst, stream);
-    }
-
-    template void bitwiseMaskNotCaller<uchar>(int, int, int, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskNotCaller<ushort>(int, int, int, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskNotCaller<uint>(int, int, int, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-
-
-    //////////////////////////////////////////////////////////////////////////
-    // Binary bitwise logical matrix operations
-
-    enum { BIN_OP_OR, BIN_OP_AND, BIN_OP_XOR };
-
-    template <typename T, int opid>
-    struct BinOp;
-
-    template <typename T>
-    struct BinOp<T, BIN_OP_OR>
-    {
-        static __device__ __forceinline__ T call(T a, T b) { return a | b; }
+        __device__ __forceinline__ VMin4() {}
+        __device__ __forceinline__ VMin4(const VMin4& other) {}
     };
 
+    ////////////////////////////////////
 
-    template <typename T>
-    struct BinOp<T, BIN_OP_AND>
+    template <typename T> struct VMin2;
+    template <> struct VMin2<uint> : binary_function<uint, uint, uint>
     {
-        static __device__ __forceinline__ T call(T a, T b) { return a & b; }
-    };
-
-    template <typename T>
-    struct BinOp<T, BIN_OP_XOR>
-    {
-        static __device__ __forceinline__ T call(T a, T b) { return a ^ b; }
-    };
-
-
-    template <int opid>
-    __global__ void bitwiseBinOpKernel(int rows, int width, const PtrStepb src1,
-                                       const PtrStepb src2, PtrStepb dst)
-    {
-        const int x = (blockDim.x * blockIdx.x + threadIdx.x) * 4;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (y < rows)
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
         {
-            uchar* dst_ptr = dst.ptr(y) + x;
-            const uchar* src1_ptr = src1.ptr(y) + x;
-            const uchar* src2_ptr = src2.ptr(y) + x;
+            uint res = 0;
 
-            if (x + sizeof(uint) - 1 < width)
-            {
-                *(uint*)dst_ptr = BinOp<uint, opid>::call(*(uint*)src1_ptr, *(uint*)src2_ptr);
-            }
-            else
-            {
-                const uchar* src1_end = src1.ptr(y) + width;
-                while (src1_ptr < src1_end)
-                {
-                    *dst_ptr++ = BinOp<uchar, opid>::call(*src1_ptr++, *src2_ptr++);
-                }
-            }
+        #if __CUDA_ARCH__ >= 300
+            asm("vmin2.u32.u32.u32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmin.u32.u32.u32 %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.u32.u32.u32 %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
         }
-    }
 
-
-    template <int opid>
-    void bitwiseBinOp(int rows, int width, const PtrStepb src1, const PtrStepb src2,
-                      PtrStepb dst, cudaStream_t stream)
+        __device__ __forceinline__ VMin2() {}
+        __device__ __forceinline__ VMin2(const VMin2& other) {}
+    };
+    template <> struct VMin2<int> : binary_function<int, int, int>
     {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(width, threads.x * sizeof(uint)), divUp(rows, threads.y));
-
-        bitwiseBinOpKernel<opid><<<grid, threads>>>(rows, width, src1, src2, dst);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
-    }
-
-
-    template <typename T, int opid>
-    __global__ void bitwiseBinOpKernel(
-            int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2,
-            const PtrStepb mask, PtrStepb dst)
-    {
-        const int x = blockDim.x * blockIdx.x + threadIdx.x;
-        const int y = blockDim.y * blockIdx.y + threadIdx.y;
-
-        if (x < cols && y < rows && mask.ptr(y)[x / cn])
+        __device__ __forceinline__ int operator ()(int a, int b) const
         {
-            T* dst_row = (T*)dst.ptr(y);
-            const T* src1_row = (const T*)src1.ptr(y);
-            const T* src2_row = (const T*)src2.ptr(y);
+            int res = 0;
 
-            dst_row[x] = BinOp<T, opid>::call(src1_row[x], src2_row[x]);
+        #if __CUDA_ARCH__ >= 300
+            asm("vmin2.s32.s32.s32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmin.s32.s32.s32 %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmin.s32.s32.s32 %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
         }
+
+        __device__ __forceinline__ VMin2() {}
+        __device__ __forceinline__ VMin2(const VMin2& other) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T> struct TransformFunctorTraits< VMin4<T> > : DefaultTransformFunctorTraits< VMin4<T> >
+    {
+                enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+
+    ////////////////////////////////////
+
+    template <typename T> struct TransformFunctorTraits< VMin2<T> > : DefaultTransformFunctorTraits< VMin2<T> >
+    {
+                enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+
+    ////////////////////////////////////
+
+    template <> struct TransformFunctorTraits< minimum<ushort> > : DefaultTransformFunctorTraits< minimum<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< minimum<short> > : DefaultTransformFunctorTraits< minimum<short> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< minimum<int> > : DefaultTransformFunctorTraits< minimum<int> >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< minimum<float> > : DefaultTransformFunctorTraits< minimum<float> >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct TransformFunctorTraits< binder2nd< minimum<ushort> > > : DefaultTransformFunctorTraits< binder2nd< minimum<ushort> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< minimum<short> > > : DefaultTransformFunctorTraits< binder2nd< minimum<short> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< minimum<int> > > : DefaultTransformFunctorTraits< binder2nd< minimum<int> > >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< minimum<float> > > : DefaultTransformFunctorTraits< binder2nd< minimum<float> > >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T> void vmin4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VMin4<T>(), WithOutMask(), stream);
     }
 
-
-    template <typename T, int opid>
-    void bitwiseBinOp(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2,
-                        const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
+    template <typename T> void vmin2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        dim3 threads(16, 16);
-        dim3 grid(divUp(cols, threads.x), divUp(rows, threads.y));
-
-        bitwiseBinOpKernel<T, opid><<<grid, threads>>>(rows, cols, cn, src1, src2, mask, dst);
-        cudaSafeCall( cudaGetLastError() );
-
-        if (stream == 0)
-            cudaSafeCall( cudaDeviceSynchronize() );
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VMin2<T>(), WithOutMask(), stream);
     }
 
-
-    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1,
-                         const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
+    template <typename T> void minMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        bitwiseBinOp<BIN_OP_OR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, minimum<T>(), WithOutMask(), stream);
     }
 
+    template void vmin4<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vmin4<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template <typename T>
-    void bitwiseMaskOrCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2,
-                             const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
+    template void vmin2<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vmin2<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template void minMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T> void minScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        bitwiseBinOp<T, BIN_OP_OR>(rows, cols * cn, cn, src1, src2, mask, dst, stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(minimum<T>(), src2), WithOutMask(), stream);
     }
 
-    template void bitwiseMaskOrCaller<uchar>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskOrCaller<ushort>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskOrCaller<uint>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
+    template void minScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<schar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<ushort>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<short >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<int   >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<float >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void minScalar<double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+}
 
+//////////////////////////////////////////////////////////////////////////
+// max
 
-    void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1,
-                          const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
+namespace
+{
+    template <typename T> struct VMax4;
+    template <> struct VMax4<uint> : binary_function<uint, uint, uint>
     {
-        bitwiseBinOp<BIN_OP_AND>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
-    }
-
-
-    template <typename T>
-    void bitwiseMaskAndCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2,
-                              const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseBinOp<T, BIN_OP_AND>(rows, cols * cn, cn, src1, src2, mask, dst, stream);
-    }
-
-    template void bitwiseMaskAndCaller<uchar>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskAndCaller<ushort>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskAndCaller<uint>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-
-
-    void bitwiseXorCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1,
-                          const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseBinOp<BIN_OP_XOR>(rows, static_cast<int>(cols * elem_size1 * cn), src1, src2, dst, stream);
-    }
-
-
-    template <typename T>
-    void bitwiseMaskXorCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2,
-                              const PtrStepb mask, PtrStepb dst, cudaStream_t stream)
-    {
-        bitwiseBinOp<T, BIN_OP_XOR>(rows, cols * cn, cn, src1, src2, mask, dst, stream);
-    }
-
-    template void bitwiseMaskXorCaller<uchar>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskXorCaller<ushort>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-    template void bitwiseMaskXorCaller<uint>(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-
-    //////////////////////////////////////////////////////////////////////////
-    // min/max
-
-    namespace detail
-    {
-        template <size_t size, typename F> struct MinMaxTraits : DefaultTransformFunctorTraits<F>
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
         {
-        };
-        template <typename F> struct MinMaxTraits<2, F> : DefaultTransformFunctorTraits<F>
+            uint res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vmax4.u32.u32.u32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmax.u32.u32.u32 %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.u32.u32.u32 %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.u32.u32.u32 %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.u32.u32.u32 %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VMax4() {}
+        __device__ __forceinline__ VMax4(const VMax4& other) {}
+    };
+    template <> struct VMax4<int> : binary_function<int, int, int>
+    {
+        __device__ __forceinline__ int operator ()(int a, int b) const
         {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct MinMaxTraits<4, F> : DefaultTransformFunctorTraits<F>
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vmax4.s32.s32.s32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmax.s32.s32.s32 %0.b0, %1.b0, %2.b0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.s32.s32.s32 %0.b1, %1.b1, %2.b1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.s32.s32.s32 %0.b2, %1.b2, %2.b2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.s32.s32.s32 %0.b3, %1.b3, %2.b3, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VMax4() {}
+        __device__ __forceinline__ VMax4(const VMax4& other) {}
+    };
+
+    ////////////////////////////////////
+
+    template <typename T> struct VMax2;
+    template <> struct VMax2<uint> : binary_function<uint, uint, uint>
+    {
+        __device__ __forceinline__ uint operator ()(uint a, uint b) const
         {
-            enum { smart_block_dim_y = 4 };
-            enum { smart_shift = 4 };
-        };
-    }
+            uint res = 0;
 
-    template <typename T> struct TransformFunctorTraits< minimum<T> > : detail::MinMaxTraits< sizeof(T), minimum<T> >
-    {
+        #if __CUDA_ARCH__ >= 300
+            asm("vmax2.u32.u32.u32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmax.u32.u32.u32 %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.u32.u32.u32 %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VMax2() {}
+        __device__ __forceinline__ VMax2(const VMax2& other) {}
     };
-    template <typename T> struct TransformFunctorTraits< maximum<T> > : detail::MinMaxTraits< sizeof(T), maximum<T> >
+    template <> struct VMax2<int> : binary_function<int, int, int>
     {
+        __device__ __forceinline__ int operator ()(int a, int b) const
+        {
+            int res = 0;
+
+        #if __CUDA_ARCH__ >= 300
+            asm("vmax2.s32.s32.s32 %0, %1, %2, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #elif __CUDA_ARCH__ >= 200
+            asm("vmax.s32.s32.s32 %0.h0, %1.h0, %2.h0, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+            asm("vmax.s32.s32.s32 %0.h1, %1.h1, %2.h1, %3;" : "=r"(res) : "r"(a), "r"(b), "r"(res));
+        #endif
+
+            return res;
+        }
+
+        __device__ __forceinline__ VMax2() {}
+        __device__ __forceinline__ VMax2(const VMax2& other) {}
     };
-    template <typename T> struct TransformFunctorTraits< binder2nd< minimum<T> > > : detail::MinMaxTraits< sizeof(T), binder2nd< minimum<T> > >
-    {
-    };
-    template <typename T> struct TransformFunctorTraits< binder2nd< maximum<T> > > : detail::MinMaxTraits< sizeof(T), binder2nd< maximum<T> > >
+}
+
+namespace cv { namespace gpu { namespace device
+{
+    template <typename T> struct TransformFunctorTraits< VMax4<T> > : DefaultTransformFunctorTraits< VMax4<T> >
     {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
     };
 
-    template <typename T>
-    void min_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    ////////////////////////////////////
+
+    template <typename T> struct TransformFunctorTraits< VMax2<T> > : DefaultTransformFunctorTraits< VMax2<T> >
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<T>)dst, minimum<T>(), WithOutMask(), stream);
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+
+    ////////////////////////////////////
+
+    template <> struct TransformFunctorTraits< maximum<ushort> > : DefaultTransformFunctorTraits< maximum<ushort> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< maximum<short> > : DefaultTransformFunctorTraits< maximum<short> >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< maximum<int> > : DefaultTransformFunctorTraits< maximum<int> >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< maximum<float> > : DefaultTransformFunctorTraits< maximum<float> >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct TransformFunctorTraits< binder2nd< maximum<ushort> > > : DefaultTransformFunctorTraits< binder2nd< maximum<ushort> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< maximum<short> > > : DefaultTransformFunctorTraits< binder2nd< maximum<short> > >
+    {
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< maximum<int> > > : DefaultTransformFunctorTraits< binder2nd< maximum<int> > >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct TransformFunctorTraits< binder2nd< maximum<float> > > : DefaultTransformFunctorTraits< binder2nd< maximum<float> > >
+    {
+        enum { smart_block_dim_y = 4 };
+        enum { smart_shift = 4 };
+    };
+}}}
+
+namespace arithm
+{
+    template <typename T> void vmax4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    {
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VMax4<T>(), WithOutMask(), stream);
     }
 
-    template void min_gpu<uchar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<schar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<ushort>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<short >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<int   >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<float >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<double>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-
-    template <typename T>
-    void max_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void vmax2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src1, (PtrStepSz<T>)src2, (PtrStepSz<T>)dst, maximum<T>(), WithOutMask(), stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, VMax2<T>(), WithOutMask(), stream);
     }
 
-    template void max_gpu<uchar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<schar >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<ushort>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<short >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<int   >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<float >(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<double>(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-
-    template <typename T>
-    void min_gpu(const PtrStepSzb src, T val, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> void maxMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, device::bind2nd(minimum<T>(), val), WithOutMask(), stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, (PtrStepSz<T>) dst, maximum<T>(), WithOutMask(), stream);
     }
 
-    template void min_gpu<uchar >(const PtrStepSzb src, uchar  val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<schar >(const PtrStepSzb src, schar  val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<ushort>(const PtrStepSzb src, ushort val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<short >(const PtrStepSzb src, short  val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<int   >(const PtrStepSzb src, int    val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<float >(const PtrStepSzb src, float  val, PtrStepSzb dst, cudaStream_t stream);
-    template void min_gpu<double>(const PtrStepSzb src, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void vmax4<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vmax4<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template <typename T>
-    void max_gpu(const PtrStepSzb src, T val, PtrStepSzb dst, cudaStream_t stream)
+    template void vmax2<uint>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void vmax2<int>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template void maxMat<uchar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<schar >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<ushort>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<short >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<int   >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<float >(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxMat<double>(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T> void maxScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, device::bind2nd(maximum<T>(), val), WithOutMask(), stream);
+        transform((PtrStepSz<T>) src1, (PtrStepSz<T>) dst, cv::gpu::device::bind2nd(maximum<T>(), src2), WithOutMask(), stream);
     }
 
-    template void max_gpu<uchar >(const PtrStepSzb src, uchar  val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<schar >(const PtrStepSzb src, schar  val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<ushort>(const PtrStepSzb src, ushort val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<short >(const PtrStepSzb src, short  val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<int   >(const PtrStepSzb src, int    val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<float >(const PtrStepSzb src, float  val, PtrStepSzb dst, cudaStream_t stream);
-    template void max_gpu<double>(const PtrStepSzb src, double val, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<uchar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<schar >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<ushort>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<short >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<int   >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<float >(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    template void maxScalar<double>(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////
-    // threshold
+//////////////////////////////////////////////////////////////////////////
+// threshold
 
+namespace cv { namespace gpu { namespace device
+{
     namespace detail
     {
         template <size_t size, typename F> struct ThresholdTraits : DefaultTransformFunctorTraits<F>
@@ -1874,19 +3021,21 @@ namespace cv { namespace gpu { namespace device
     template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_to_zero_inv_func<T> >
     {
     };
+}}}
 
+namespace arithm
+{
     template <template <typename> class Op, typename T>
-    void threshold_caller(const PtrStepSz<T>& src, const PtrStepSz<T>& dst, T thresh, T maxVal, cudaStream_t stream)
+    void threshold_caller(PtrStepSz<T> src, PtrStepSz<T> dst, T thresh, T maxVal, cudaStream_t stream)
     {
         Op<T> op(thresh, maxVal);
-        cv::gpu::device::transform(src, dst, op, WithOutMask(), stream);
+        transform(src, dst, op, WithOutMask(), stream);
     }
 
     template <typename T>
-    void threshold_gpu(const PtrStepSzb& src, const PtrStepSzb& dst, T thresh, T maxVal, int type,
-        cudaStream_t stream)
+    void threshold(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream)
     {
-        typedef void (*caller_t)(const PtrStepSz<T>& src, const PtrStepSz<T>& dst, T thresh, T maxVal, cudaStream_t stream);
+        typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<T> dst, T thresh, T maxVal, cudaStream_t stream);
 
         static const caller_t callers[] =
         {
@@ -1897,23 +3046,26 @@ namespace cv { namespace gpu { namespace device
             threshold_caller<thresh_to_zero_inv_func, T>
         };
 
-        callers[type]((PtrStepSz<T>)src, (PtrStepSz<T>)dst, thresh, maxVal, stream);
+        callers[type]((PtrStepSz<T>) src, (PtrStepSz<T>) dst, static_cast<T>(thresh), static_cast<T>(maxVal), stream);
     }
 
-    template void threshold_gpu<uchar>(const PtrStepSzb& src, const PtrStepSzb& dst, uchar thresh, uchar maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<schar>(const PtrStepSzb& src, const PtrStepSzb& dst, schar thresh, schar maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<ushort>(const PtrStepSzb& src, const PtrStepSzb& dst, ushort thresh, ushort maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<short>(const PtrStepSzb& src, const PtrStepSzb& dst, short thresh, short maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<int>(const PtrStepSzb& src, const PtrStepSzb& dst, int thresh, int maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<float>(const PtrStepSzb& src, const PtrStepSzb& dst, float thresh, float maxVal, int type, cudaStream_t stream);
-    template void threshold_gpu<double>(const PtrStepSzb& src, const PtrStepSzb& dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<uchar>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<schar>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<ushort>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<short>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<int>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<float>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+    template void threshold<double>(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////
-    // pow
+//////////////////////////////////////////////////////////////////////////
+// pow
 
-    template<typename T, bool Signed = device::numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
+namespace
+{
+    template<typename T, bool Signed = numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
     {
-        const float power;
+        float power;
 
         PowOp(double power_) : power(static_cast<float>(power_)) {}
 
@@ -1924,7 +3076,7 @@ namespace cv { namespace gpu { namespace device
     };
     template<typename T> struct PowOp<T, true> : unary_function<T, T>
     {
-        const float power;
+        float power;
 
         PowOp(double power_) : power(static_cast<float>(power_)) {}
 
@@ -1951,7 +3103,7 @@ namespace cv { namespace gpu { namespace device
     };
     template<> struct PowOp<double> : unary_function<double, double>
     {
-        const double power;
+        double power;
 
         PowOp(double power_) : power(power_) {}
 
@@ -1960,7 +3112,10 @@ namespace cv { namespace gpu { namespace device
             return ::pow(::fabs(e), power);
         }
     };
+}
 
+namespace cv { namespace gpu { namespace device
+{
     namespace detail
     {
         template <size_t size, typename T> struct PowOpTraits : DefaultTransformFunctorTraits< PowOp<T> >
@@ -1985,83 +3140,78 @@ namespace cv { namespace gpu { namespace device
     template <typename T> struct TransformFunctorTraits< PowOp<T> > : detail::PowOpTraits<sizeof(T), T>
     {
     };
+}}}
 
+namespace arithm
+{
     template<typename T>
-    void pow_caller(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream)
+    void pow(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream)
     {
-        cv::gpu::device::transform((PtrStepSz<T>)src, (PtrStepSz<T>)dst, PowOp<T>(power), WithOutMask(), stream);
+        transform((PtrStepSz<T>) src, (PtrStepSz<T>) dst, PowOp<T>(power), WithOutMask(), stream);
     }
 
-    template void pow_caller<uchar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<schar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<short>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<ushort>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<int>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<float>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-    template void pow_caller<double>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<uchar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<schar>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<short>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<ushort>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<int>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<float>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+    template void pow<double>(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+}
 
-    //////////////////////////////////////////////////////////////////////////
-    // addWeighted
+//////////////////////////////////////////////////////////////////////////
+// addWeighted
 
-    namespace detail
+namespace
+{
+    template <typename T> struct UseDouble_
     {
-        template <typename T> struct UseDouble
-        {
-            enum {value = 0};
-        };
-        template <> struct UseDouble<int>
-        {
-            enum {value = 1};
-        };
-        template <> struct UseDouble<float>
-        {
-            enum {value = 1};
-        };
-        template <> struct UseDouble<double>
-        {
-            enum {value = 1};
-        };
-    }
+        enum {value = 0};
+    };
+    template <> struct UseDouble_<double>
+    {
+        enum {value = 1};
+    };
     template <typename T1, typename T2, typename D> struct UseDouble
     {
-        enum {value = (detail::UseDouble<T1>::value || detail::UseDouble<T2>::value || detail::UseDouble<D>::value)};
+        enum {value = (UseDouble_<T1>::value || UseDouble_<T2>::value || UseDouble_<D>::value)};
     };
 
-    namespace detail
+    template <typename T1, typename T2, typename D, bool useDouble> struct AddWeighted_;
+    template <typename T1, typename T2, typename D> struct AddWeighted_<T1, T2, D, false> : binary_function<T1, T2, D>
     {
-        template <typename T1, typename T2, typename D, bool useDouble> struct AddWeighted;
-        template <typename T1, typename T2, typename D> struct AddWeighted<T1, T2, D, false> : binary_function<T1, T2, D>
+        float alpha;
+        float beta;
+        float gamma;
+
+        AddWeighted_(double alpha_, double beta_, double gamma_) : alpha(static_cast<float>(alpha_)), beta(static_cast<float>(beta_)), gamma(static_cast<float>(gamma_)) {}
+
+        __device__ __forceinline__ D operator ()(T1 a, T2 b) const
         {
-            AddWeighted(double alpha_, double beta_, double gamma_) : alpha(static_cast<float>(alpha_)), beta(static_cast<float>(beta_)), gamma(static_cast<float>(gamma_)) {}
-
-            __device__ __forceinline__ D operator ()(T1 a, T2 b) const
-            {
-                return saturate_cast<D>(a * alpha + b * beta + gamma);
-            }
-
-            const float alpha;
-            const float beta;
-            const float gamma;
-        };
-        template <typename T1, typename T2, typename D> struct AddWeighted<T1, T2, D, true> : binary_function<T1, T2, D>
-        {
-            AddWeighted(double alpha_, double beta_, double gamma_) : alpha(alpha_), beta(beta_), gamma(gamma_) {}
-
-            __device__ __forceinline__ D operator ()(T1 a, T2 b) const
-            {
-                return saturate_cast<D>(a * alpha + b * beta + gamma);
-            }
-
-            const double alpha;
-            const double beta;
-            const double gamma;
-        };
-    }
-    template <typename T1, typename T2, typename D> struct AddWeighted : detail::AddWeighted<T1, T2, D, UseDouble<T1, T2, D>::value>
-    {
-        AddWeighted(double alpha_, double beta_, double gamma_) : detail::AddWeighted<T1, T2, D, UseDouble<T1, T2, D>::value>(alpha_, beta_, gamma_) {}
+            return saturate_cast<D>(a * alpha + b * beta + gamma);
+        }
     };
+    template <typename T1, typename T2, typename D> struct AddWeighted_<T1, T2, D, true> : binary_function<T1, T2, D>
+    {
+        double alpha;
+        double beta;
+        double gamma;
 
+        AddWeighted_(double alpha_, double beta_, double gamma_) : alpha(alpha_), beta(beta_), gamma(gamma_) {}
+
+        __device__ __forceinline__ D operator ()(T1 a, T2 b) const
+        {
+            return saturate_cast<D>(a * alpha + b * beta + gamma);
+        }
+    };
+    template <typename T1, typename T2, typename D> struct AddWeighted : AddWeighted_<T1, T2, D, UseDouble<T1, T2, D>::value>
+    {
+        AddWeighted(double alpha_, double beta_, double gamma_) : AddWeighted_<T1, T2, D, UseDouble<T1, T2, D>::value>(alpha_, beta_, gamma_) {}
+    };
+}
+
+namespace cv { namespace gpu { namespace device
+{
     template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, ushort> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, ushort> >
     {
         enum { smart_shift = 4 };
@@ -2117,257 +3267,253 @@ namespace cv { namespace gpu { namespace device
         enum { smart_block_dim_y = 8 };
         enum { smart_shift = 4 };
     };
+}}}
 
+namespace arithm
+{
     template <typename T1, typename T2, typename D>
-    void addWeighted_gpu(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream)
+    void addWeighted(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream)
     {
-        if (UseDouble<T1, T2, D>::value)
-        {
-            cudaSafeCall( cudaSetDoubleForDevice(&alpha) );
-            cudaSafeCall( cudaSetDoubleForDevice(&beta) );
-            cudaSafeCall( cudaSetDoubleForDevice(&gamma) );
-        }
-
         AddWeighted<T1, T2, D> op(alpha, beta, gamma);
 
-        cv::gpu::device::transform(static_cast< PtrStepSz<T1> >(src1), static_cast< PtrStepSz<T2> >(src2), static_cast< PtrStepSz<D> >(dst), op, WithOutMask(), stream);
+        transform((PtrStepSz<T1>) src1, (PtrStepSz<T2>) src2, (PtrStepSz<D>) dst, op, WithOutMask(), stream);
     }
 
-    template void addWeighted_gpu<uchar, uchar, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, uchar, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, uchar, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, schar, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, schar, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, schar, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, ushort, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, ushort, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, ushort, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, short, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, short, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, short, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, int, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, int, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, int, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<uchar, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<uchar, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<uchar, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<schar, schar, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, schar, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, schar, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<schar, ushort, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, ushort, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, ushort, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<schar, short, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, short, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, short, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, short, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<schar, int, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, int, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, int, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, int, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<schar, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<schar, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<schar, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<schar, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<schar, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<ushort, ushort, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, ushort, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, ushort, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<ushort, short, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, short, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, short, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<ushort, int, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, int, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, int, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<ushort, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<ushort, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<ushort, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<ushort, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<short, short, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, short, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<short, short, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, short, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<short, int, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, int, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<short, int, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, int, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<short, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<short, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<short, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<short, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<short, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<short, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<int, int, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, int, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<int, int, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, int, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<int, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<int, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<int, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<int, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<int, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<int, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<float, float, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, float, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<float, float, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, float, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
-    template void addWeighted_gpu<float, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<float, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
+    template void addWeighted<float, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<float, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
 
 
 
-    template void addWeighted_gpu<double, double, uchar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, schar>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, ushort>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, short>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, int>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, float>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-    template void addWeighted_gpu<double, double, double>(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-}}} // namespace cv { namespace gpu { namespace device
+    template void addWeighted<double, double, uchar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, schar>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, ushort>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, short>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, int>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, float>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+    template void addWeighted<double, double, double>(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+}
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/element_operations.cpp b/modules/gpu/src/element_operations.cpp
index 2a22b2ffb..1943b315d 100644
--- a/modules/gpu/src/element_operations.cpp
+++ b/modules/gpu/src/element_operations.cpp
@@ -99,58 +99,6 @@ namespace
     template<> struct NppTypeTraits<CV_32F> { typedef Npp32f npp_t; typedef Npp32fc npp_complex_type; };
     template<> struct NppTypeTraits<CV_64F> { typedef Npp64f npp_t; typedef Npp64fc npp_complex_type; };
 
-    template <int DEPTH> struct NppArithmFunc
-    {
-        typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc1, int nSrc1Step, const npp_t* pSrc2, int nSrc2Step, npp_t* pDst, int nDstStep, NppiSize oSizeROI, int nScaleFactor);
-    };
-    template <> struct NppArithmFunc<CV_32F>
-    {
-        typedef NppTypeTraits<CV_32F>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const Npp32f* pSrc1, int nSrc1Step, const Npp32f* pSrc2, int nSrc2Step, Npp32f* pDst, int nDstStep, NppiSize oSizeROI);
-    };
-
-    template <int DEPTH, typename NppArithmFunc<DEPTH>::func_t func> struct NppArithm
-    {
-        typedef typename NppArithmFunc<DEPTH>::npp_t npp_t;
-
-        static void call(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize sz;
-            sz.width  = src1.cols;
-            sz.height = src1.rows;
-
-            nppSafeCall( func((const npp_t*)src1.data, static_cast<int>(src1.step), (const npp_t*)src2.data, static_cast<int>(src2.step),
-                              (npp_t*)dst.data, static_cast<int>(dst.step), sz, 0) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template <typename NppArithmFunc<CV_32F>::func_t func> struct NppArithm<CV_32F, func>
-    {
-        typedef typename NppArithmFunc<CV_32F>::npp_t npp_t;
-
-        static void call(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize sz;
-            sz.width  = src1.cols;
-            sz.height = src1.rows;
-
-            nppSafeCall( func((const npp_t*)src1.data, static_cast<int>(src1.step), (const npp_t*)src2.data, static_cast<int>(src2.step),
-                              (npp_t*)dst.data, static_cast<int>(dst.step), sz) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
     template<int DEPTH, int cn> struct NppArithmScalarFunc
     {
         typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
@@ -313,87 +261,294 @@ namespace
 ////////////////////////////////////////////////////////////////////////
 // add
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
     template <typename T, typename D>
-    void add_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    void vadd4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
     template <typename T, typename D>
-    void add_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-}}}
+    void vadd2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T, typename D>
+    void addMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
 
 void cv::gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {add_gpu<unsigned char, unsigned char>       , 0 /*add_gpu<unsigned char, signed char>*/ , add_gpu<unsigned char, unsigned short>    , add_gpu<unsigned char, short>       , add_gpu<unsigned char, int>    , add_gpu<unsigned char, float>    , add_gpu<unsigned char, double>    },
-        {0 /*add_gpu<signed char, unsigned char>*/   , 0 /*add_gpu<signed char, signed char>*/   , 0 /*add_gpu<signed char, unsigned short>*/, 0 /*add_gpu<signed char, short>*/   , 0 /*add_gpu<signed char, int>*/, 0 /*add_gpu<signed char, float>*/, 0 /*add_gpu<signed char, double>*/},
-        {0 /*add_gpu<unsigned short, unsigned char>*/, 0 /*add_gpu<unsigned short, signed char>*/, add_gpu<unsigned short, unsigned short>   , 0 /*add_gpu<unsigned short, short>*/, add_gpu<unsigned short, int>   , add_gpu<unsigned short, float>   , add_gpu<unsigned short, double>   },
-        {0 /*add_gpu<short, unsigned char>*/         , 0 /*add_gpu<short, signed char>*/         , 0 /*add_gpu<short, unsigned short>*/      , add_gpu<short, short>               , add_gpu<short, int>            , add_gpu<short, float>            , add_gpu<short, double>            },
-        {0 /*add_gpu<int, unsigned char>*/           , 0 /*add_gpu<int, signed char>*/           , 0 /*add_gpu<int, unsigned short>*/        , 0 /*add_gpu<int, short>*/           , add_gpu<int, int>              , add_gpu<int, float>              , add_gpu<int, double>              },
-        {0 /*add_gpu<float, unsigned char>*/         , 0 /*add_gpu<float, signed char>*/         , 0 /*add_gpu<float, unsigned short>*/      , 0 /*add_gpu<float, short>*/         , 0 /*add_gpu<float, int>*/      , add_gpu<float, float>            , add_gpu<float, double>            },
-        {0 /*add_gpu<double, unsigned char>*/        , 0 /*add_gpu<double, signed char>*/        , 0 /*add_gpu<double, unsigned short>*/     , 0 /*add_gpu<double, short>*/        , 0 /*add_gpu<double, int>*/     , 0 /*add_gpu<double, float>*/     , add_gpu<double, double>           }
+        {
+            addMat<unsigned char, unsigned char>,
+            addMat<unsigned char, signed char>,
+            addMat<unsigned char, unsigned short>,
+            addMat<unsigned char, short>,
+            addMat<unsigned char, int>,
+            addMat<unsigned char, float>,
+            addMat<unsigned char, double>
+        },
+        {
+            addMat<signed char, unsigned char>,
+            addMat<signed char, signed char>,
+            addMat<signed char, unsigned short>,
+            addMat<signed char, short>,
+            addMat<signed char, int>,
+            addMat<signed char, float>,
+            addMat<signed char, double>
+        },
+        {
+            0 /*addMat<unsigned short, unsigned char>*/,
+            0 /*addMat<unsigned short, signed char>*/,
+            addMat<unsigned short, unsigned short>,
+            addMat<unsigned short, short>,
+            addMat<unsigned short, int>,
+            addMat<unsigned short, float>,
+            addMat<unsigned short, double>
+        },
+        {
+            0 /*addMat<short, unsigned char>*/,
+            0 /*addMat<short, signed char>*/,
+            addMat<short, unsigned short>,
+            addMat<short, short>,
+            addMat<short, int>,
+            addMat<short, float>,
+            addMat<short, double>
+        },
+        {
+            0 /*addMat<int, unsigned char>*/,
+            0 /*addMat<int, signed char>*/,
+            0 /*addMat<int, unsigned short>*/,
+            0 /*addMat<int, short>*/,
+            addMat<int, int>,
+            addMat<int, float>,
+            addMat<int, double>
+        },
+        {
+            0 /*addMat<float, unsigned char>*/,
+            0 /*addMat<float, signed char>*/,
+            0 /*addMat<float, unsigned short>*/,
+            0 /*addMat<float, short>*/,
+            0 /*addMat<float, int>*/,
+            addMat<float, float>,
+            addMat<float, double>
+        },
+        {
+            0 /*addMat<double, unsigned char>*/,
+            0 /*addMat<double, signed char>*/,
+            0 /*addMat<double, unsigned short>*/,
+            0 /*addMat<double, short>*/,
+            0 /*addMat<double, int>*/,
+            0 /*addMat<double, float>*/,
+            addMat<double, double>
+        }
     };
 
-    typedef void (*npp_func_t)(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-    static const npp_func_t npp_funcs[] =
+    typedef void (*vfunc_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    static const vfunc_t vfuncs4[4][4] =
     {
-        NppArithm<CV_8U , nppiAdd_8u_C1RSfs >::call,
-        0,
-        NppArithm<CV_16U, nppiAdd_16u_C1RSfs>::call,
-        NppArithm<CV_16S, nppiAdd_16s_C1RSfs>::call,
-        NppArithm<CV_32S, nppiAdd_32s_C1RSfs>::call,
-        NppArithm<CV_32F, nppiAdd_32f_C1R   >::call
+        {
+            vadd4<unsigned int, unsigned int>,
+            vadd4<unsigned int, int>,
+            0,
+            0
+        },
+        {
+            vadd4<int, unsigned int>,
+            vadd4<int, int>,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        }
+    };
+    static const vfunc_t vfuncs2[4][4] =
+    {
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            vadd2<unsigned int, unsigned int>,
+            vadd2<unsigned int, int>
+        },
+        {
+            0,
+            0,
+            vadd2<int, unsigned int>,
+            vadd2<int, int>
+        }
     };
 
     if (dtype < 0)
         dtype = src1.depth();
 
-    CV_Assert(src1.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src1.type() == src2.type() && src1.size() == src2.size());
-    CV_Assert(mask.empty() || (src1.channels() == 1 && mask.size() == src1.size() && mask.type() == CV_8U));
+    const int sdepth = src1.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src1.channels();
 
-    if (src1.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+    CV_Assert( mask.empty() || (cn == 1 && mask.size() == src1.size() && mask.type() == CV_8U) );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src1.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src1.channels()));
+    dst.create(src1.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (mask.empty() && dst.type() == src1.type() && src1.depth() <= CV_32F)
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
+
+    if (mask.empty() && sdepth < CV_32S && ddepth < CV_32S)
     {
-        npp_funcs[src1.depth()](src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
-        return;
+        const intptr_t src1ptr = reinterpret_cast<intptr_t>(src1_.data);
+        const intptr_t src2ptr = reinterpret_cast<intptr_t>(src2_.data);
+        const intptr_t dstptr = reinterpret_cast<intptr_t>(dst_.data);
+
+        const bool isAllAligned = (src1ptr & 31) == 0 && (src2ptr & 31) == 0 && (dstptr & 31) == 0;
+
+        if (deviceSupports(FEATURE_SET_COMPUTE_20) && isAllAligned)
+        {
+            const vfunc_t vfunc4 = vfuncs4[sdepth][ddepth];
+            const vfunc_t vfunc2 = vfuncs2[sdepth][ddepth];
+
+            if (vfunc4 != 0 && (src1_.cols & 3) == 0)
+            {
+                const int vcols = src1_.cols >> 2;
+
+                vfunc4(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+
+            if (vfunc2 != 0 && (src1_.cols & 1) == 0)
+            {
+                const int vcols = src1_.cols >> 1;
+
+                vfunc2(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+        }
     }
 
-    const func_t func = funcs[src1.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(src1.reshape(1), src2.reshape(1), dst.reshape(1), mask, stream);
+    func(src1_, src2_, dst_, mask, stream);
+}
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void addScalar(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 }
 
 void cv::gpu::add(const GpuMat& src, const Scalar& sc, GpuMat& dst, const GpuMat& mask, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {add_gpu<unsigned char, unsigned char>       , 0 /*add_gpu<unsigned char, signed char>*/ , add_gpu<unsigned char, unsigned short>    , add_gpu<unsigned char, short>       , add_gpu<unsigned char, int>    , add_gpu<unsigned char, float>    , add_gpu<unsigned char, double>    },
-        {0 /*add_gpu<signed char, unsigned char>*/   , 0 /*add_gpu<signed char, signed char>*/   , 0 /*add_gpu<signed char, unsigned short>*/, 0 /*add_gpu<signed char, short>*/   , 0 /*add_gpu<signed char, int>*/, 0 /*add_gpu<signed char, float>*/, 0 /*add_gpu<signed char, double>*/},
-        {0 /*add_gpu<unsigned short, unsigned char>*/, 0 /*add_gpu<unsigned short, signed char>*/, add_gpu<unsigned short, unsigned short>   , 0 /*add_gpu<unsigned short, short>*/, add_gpu<unsigned short, int>   , add_gpu<unsigned short, float>   , add_gpu<unsigned short, double>   },
-        {0 /*add_gpu<short, unsigned char>*/         , 0 /*add_gpu<short, signed char>*/         , 0 /*add_gpu<short, unsigned short>*/      , add_gpu<short, short>               , add_gpu<short, int>            , add_gpu<short, float>            , add_gpu<short, double>            },
-        {0 /*add_gpu<int, unsigned char>*/           , 0 /*add_gpu<int, signed char>*/           , 0 /*add_gpu<int, unsigned short>*/        , 0 /*add_gpu<int, short>*/           , add_gpu<int, int>              , add_gpu<int, float>              , add_gpu<int, double>              },
-        {0 /*add_gpu<float, unsigned char>*/         , 0 /*add_gpu<float, signed char>*/         , 0 /*add_gpu<float, unsigned short>*/      , 0 /*add_gpu<float, short>*/         , 0 /*add_gpu<float, int>*/      , add_gpu<float, float>            , add_gpu<float, double>            },
-        {0 /*add_gpu<double, unsigned char>*/        , 0 /*add_gpu<double, signed char>*/        , 0 /*add_gpu<double, unsigned short>*/     , 0 /*add_gpu<double, short>*/        , 0 /*add_gpu<double, int>*/     , 0 /*add_gpu<double, float>*/     , add_gpu<double, double>           }
+        {
+            addScalar<unsigned char, float, unsigned char>,
+            addScalar<unsigned char, float, signed char>,
+            addScalar<unsigned char, float, unsigned short>,
+            addScalar<unsigned char, float, short>,
+            addScalar<unsigned char, float, int>,
+            addScalar<unsigned char, float, float>,
+            addScalar<unsigned char, double, double>
+        },
+        {
+            addScalar<signed char, float, unsigned char>,
+            addScalar<signed char, float, signed char>,
+            addScalar<signed char, float, unsigned short>,
+            addScalar<signed char, float, short>,
+            addScalar<signed char, float, int>,
+            addScalar<signed char, float, float>,
+            addScalar<signed char, double, double>
+        },
+        {
+            0 /*addScalar<unsigned short, float, unsigned char>*/,
+            0 /*addScalar<unsigned short, float, signed char>*/,
+            addScalar<unsigned short, float, unsigned short>,
+            addScalar<unsigned short, float, short>,
+            addScalar<unsigned short, float, int>,
+            addScalar<unsigned short, float, float>,
+            addScalar<unsigned short, double, double>
+        },
+        {
+            0 /*addScalar<short, float, unsigned char>*/,
+            0 /*addScalar<short, float, signed char>*/,
+            addScalar<short, float, unsigned short>,
+            addScalar<short, float, short>,
+            addScalar<short, float, int>,
+            addScalar<short, float, float>,
+            addScalar<short, double, double>
+        },
+        {
+            0 /*addScalar<int, float, unsigned char>*/,
+            0 /*addScalar<int, float, signed char>*/,
+            0 /*addScalar<int, float, unsigned short>*/,
+            0 /*addScalar<int, float, short>*/,
+            addScalar<int, float, int>,
+            addScalar<int, float, float>,
+            addScalar<int, double, double>
+        },
+        {
+            0 /*addScalar<float, float, unsigned char>*/,
+            0 /*addScalar<float, float, signed char>*/,
+            0 /*addScalar<float, float, unsigned short>*/,
+            0 /*addScalar<float, float, short>*/,
+            0 /*addScalar<float, float, int>*/,
+            addScalar<float, float, float>,
+            addScalar<float, double, double>
+        },
+        {
+            0 /*addScalar<double, double, unsigned char>*/,
+            0 /*addScalar<double, double, signed char>*/,
+            0 /*addScalar<double, double, unsigned short>*/,
+            0 /*addScalar<double, double, short>*/,
+            0 /*addScalar<double, double, int>*/,
+            0 /*addScalar<double, double, float>*/,
+            addScalar<double, double, double>
+        }
     };
 
     typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
@@ -411,34 +566,34 @@ void cv::gpu::add(const GpuMat& src, const Scalar& sc, GpuMat& dst, const GpuMat
     if (dtype < 0)
         dtype = src.depth();
 
-    CV_Assert(src.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src.channels() <= 4);
-    CV_Assert(mask.empty() || (src.channels() == 1 && mask.size() == src.size() && mask.type() == CV_8U));
+    const int sdepth = src.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( cn <= 4 );
+    CV_Assert( mask.empty() || (cn == 1 && mask.size() == src.size() && mask.type() == CV_8U) );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (mask.empty() && dst.type() == src.type())
+    const npp_func_t npp_func = npp_funcs[sdepth][cn - 1];
+    if (ddepth == sdepth && cn > 1 && npp_func != 0)
     {
-        const npp_func_t npp_func = npp_funcs[src.depth()][src.channels() - 1];
-
-        if (npp_func)
-        {
-            npp_func(src, sc, dst, stream);
-            return;
-        }
+        npp_func(src, sc, dst, stream);
+        return;
     }
 
-    CV_Assert(src.channels() == 1);
+    CV_Assert( cn == 1 );
 
-    const func_t func = funcs[src.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
@@ -449,87 +604,294 @@ void cv::gpu::add(const GpuMat& src, const Scalar& sc, GpuMat& dst, const GpuMat
 ////////////////////////////////////////////////////////////////////////
 // subtract
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
     template <typename T, typename D>
-    void subtract_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    void vsub4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
     template <typename T, typename D>
-    void subtract_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
-}}}
+    void vsub2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <typename T, typename D>
+    void subMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
 
 void cv::gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {subtract_gpu<unsigned char, unsigned char>       , 0 /*subtract_gpu<unsigned char, signed char>*/ , subtract_gpu<unsigned char, unsigned short>    , subtract_gpu<unsigned char, short>       , subtract_gpu<unsigned char, int>    , subtract_gpu<unsigned char, float>    , subtract_gpu<unsigned char, double>    },
-        {0 /*subtract_gpu<signed char, unsigned char>*/   , 0 /*subtract_gpu<signed char, signed char>*/   , 0 /*subtract_gpu<signed char, unsigned short>*/, 0 /*subtract_gpu<signed char, short>*/   , 0 /*subtract_gpu<signed char, int>*/, 0 /*subtract_gpu<signed char, float>*/, 0 /*subtract_gpu<signed char, double>*/},
-        {0 /*subtract_gpu<unsigned short, unsigned char>*/, 0 /*subtract_gpu<unsigned short, signed char>*/, subtract_gpu<unsigned short, unsigned short>   , 0 /*subtract_gpu<unsigned short, short>*/, subtract_gpu<unsigned short, int>   , subtract_gpu<unsigned short, float>   , subtract_gpu<unsigned short, double>   },
-        {0 /*subtract_gpu<short, unsigned char>*/         , 0 /*subtract_gpu<short, signed char>*/         , 0 /*subtract_gpu<short, unsigned short>*/      , subtract_gpu<short, short>               , subtract_gpu<short, int>            , subtract_gpu<short, float>            , subtract_gpu<short, double>            },
-        {0 /*subtract_gpu<int, unsigned char>*/           , 0 /*subtract_gpu<int, signed char>*/           , 0 /*subtract_gpu<int, unsigned short>*/        , 0 /*subtract_gpu<int, short>*/           , subtract_gpu<int, int>              , subtract_gpu<int, float>              , subtract_gpu<int, double>              },
-        {0 /*subtract_gpu<float, unsigned char>*/         , 0 /*subtract_gpu<float, signed char>*/         , 0 /*subtract_gpu<float, unsigned short>*/      , 0 /*subtract_gpu<float, short>*/         , 0 /*subtract_gpu<float, int>*/      , subtract_gpu<float, float>            , subtract_gpu<float, double>            },
-        {0 /*subtract_gpu<double, unsigned char>*/        , 0 /*subtract_gpu<double, signed char>*/        , 0 /*subtract_gpu<double, unsigned short>*/     , 0 /*subtract_gpu<double, short>*/        , 0 /*subtract_gpu<double, int>*/     , 0 /*subtract_gpu<double, float>*/     , subtract_gpu<double, double>           }
+        {
+            subMat<unsigned char, unsigned char>,
+            subMat<unsigned char, signed char>,
+            subMat<unsigned char, unsigned short>,
+            subMat<unsigned char, short>,
+            subMat<unsigned char, int>,
+            subMat<unsigned char, float>,
+            subMat<unsigned char, double>
+        },
+        {
+            subMat<signed char, unsigned char>,
+            subMat<signed char, signed char>,
+            subMat<signed char, unsigned short>,
+            subMat<signed char, short>,
+            subMat<signed char, int>,
+            subMat<signed char, float>,
+            subMat<signed char, double>
+        },
+        {
+            0 /*subMat<unsigned short, unsigned char>*/,
+            0 /*subMat<unsigned short, signed char>*/,
+            subMat<unsigned short, unsigned short>,
+            subMat<unsigned short, short>,
+            subMat<unsigned short, int>,
+            subMat<unsigned short, float>,
+            subMat<unsigned short, double>
+        },
+        {
+            0 /*subMat<short, unsigned char>*/,
+            0 /*subMat<short, signed char>*/,
+            subMat<short, unsigned short>,
+            subMat<short, short>,
+            subMat<short, int>,
+            subMat<short, float>,
+            subMat<short, double>
+        },
+        {
+            0 /*subMat<int, unsigned char>*/,
+            0 /*subMat<int, signed char>*/,
+            0 /*subMat<int, unsigned short>*/,
+            0 /*subMat<int, short>*/,
+            subMat<int, int>,
+            subMat<int, float>,
+            subMat<int, double>
+        },
+        {
+            0 /*subMat<float, unsigned char>*/,
+            0 /*subMat<float, signed char>*/,
+            0 /*subMat<float, unsigned short>*/,
+            0 /*subMat<float, short>*/,
+            0 /*subMat<float, int>*/,
+            subMat<float, float>,
+            subMat<float, double>
+        },
+        {
+            0 /*subMat<double, unsigned char>*/,
+            0 /*subMat<double, signed char>*/,
+            0 /*subMat<double, unsigned short>*/,
+            0 /*subMat<double, short>*/,
+            0 /*subMat<double, int>*/,
+            0 /*subMat<double, float>*/,
+            subMat<double, double>
+        }
     };
 
-    typedef void (*npp_func_t)(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-    static const npp_func_t npp_funcs[6] =
+    typedef void (*vfunc_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    static const vfunc_t vfuncs4[4][4] =
     {
-        NppArithm<CV_8U , nppiSub_8u_C1RSfs>::call,
-        0,
-        NppArithm<CV_16U, nppiSub_16u_C1RSfs>::call,
-        NppArithm<CV_16S, nppiSub_16s_C1RSfs>::call,
-        NppArithm<CV_32S, nppiSub_32s_C1RSfs>::call,
-        NppArithm<CV_32F, nppiSub_32f_C1R   >::call
+        {
+            vsub4<unsigned int, unsigned int>,
+            vsub4<unsigned int, int>,
+            0,
+            0
+        },
+        {
+            vsub4<int, unsigned int>,
+            vsub4<int, int>,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        }
+    };
+    static const vfunc_t vfuncs2[4][4] =
+    {
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            0,
+            0
+        },
+        {
+            0,
+            0,
+            vsub2<unsigned int, unsigned int>,
+            vsub2<unsigned int, int>
+        },
+        {
+            0,
+            0,
+            vsub2<int, unsigned int>,
+            vsub2<int, int>
+        }
     };
 
     if (dtype < 0)
         dtype = src1.depth();
 
-    CV_Assert(src1.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src1.type() == src2.type() && src1.size() == src2.size());
-    CV_Assert(mask.empty() || (src1.channels() == 1 && mask.size() == src1.size() && mask.type() == CV_8U));
+    const int sdepth = src1.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src1.channels();
 
-    if (src1.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+    CV_Assert( mask.empty() || (cn == 1 && mask.size() == src1.size() && mask.type() == CV_8U) );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src1.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src1.channels()));
+    dst.create(src1.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (mask.empty() && dst.type() == src1.type() && src1.depth() <= CV_32F)
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
+
+    if (mask.empty() && sdepth < CV_32S && ddepth < CV_32S)
     {
-        npp_funcs[src1.depth()](src2.reshape(1), src1.reshape(1), dst.reshape(1), stream);
-        return;
+        const intptr_t src1ptr = reinterpret_cast<intptr_t>(src1_.data);
+        const intptr_t src2ptr = reinterpret_cast<intptr_t>(src2_.data);
+        const intptr_t dstptr = reinterpret_cast<intptr_t>(dst_.data);
+
+        const bool isAllAligned = (src1ptr & 31) == 0 && (src2ptr & 31) == 0 && (dstptr & 31) == 0;
+
+        if (deviceSupports(FEATURE_SET_COMPUTE_20) && isAllAligned)
+        {
+            const vfunc_t vfunc4 = vfuncs4[sdepth][ddepth];
+            const vfunc_t vfunc2 = vfuncs2[sdepth][ddepth];
+
+            if (vfunc4 != 0 && (src1_.cols & 3) == 0)
+            {
+                const int vcols = src1_.cols >> 2;
+
+                vfunc4(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+
+            if (vfunc2 != 0 && (src1_.cols & 1) == 0)
+            {
+                const int vcols = src1_.cols >> 1;
+
+                vfunc2(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+        }
     }
 
-    const func_t func = funcs[src1.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(src1.reshape(1), src2.reshape(1), dst.reshape(1), mask, stream);
+    func(src1_, src2_, dst_, mask, stream);
+}
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void subScalar(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 }
 
 void cv::gpu::subtract(const GpuMat& src, const Scalar& sc, GpuMat& dst, const GpuMat& mask, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, const PtrStepb& mask, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {subtract_gpu<unsigned char, unsigned char>       , 0 /*subtract_gpu<unsigned char, signed char>*/ , subtract_gpu<unsigned char, unsigned short>    , subtract_gpu<unsigned char, short>       , subtract_gpu<unsigned char, int>    , subtract_gpu<unsigned char, float>    , subtract_gpu<unsigned char, double>    },
-        {0 /*subtract_gpu<signed char, unsigned char>*/   , 0 /*subtract_gpu<signed char, signed char>*/   , 0 /*subtract_gpu<signed char, unsigned short>*/, 0 /*subtract_gpu<signed char, short>*/   , 0 /*subtract_gpu<signed char, int>*/, 0 /*subtract_gpu<signed char, float>*/, 0 /*subtract_gpu<signed char, double>*/},
-        {0 /*subtract_gpu<unsigned short, unsigned char>*/, 0 /*subtract_gpu<unsigned short, signed char>*/, subtract_gpu<unsigned short, unsigned short>   , 0 /*subtract_gpu<unsigned short, short>*/, subtract_gpu<unsigned short, int>   , subtract_gpu<unsigned short, float>   , subtract_gpu<unsigned short, double>   },
-        {0 /*subtract_gpu<short, unsigned char>*/         , 0 /*subtract_gpu<short, signed char>*/         , 0 /*subtract_gpu<short, unsigned short>*/      , subtract_gpu<short, short>               , subtract_gpu<short, int>            , subtract_gpu<short, float>            , subtract_gpu<short, double>            },
-        {0 /*subtract_gpu<int, unsigned char>*/           , 0 /*subtract_gpu<int, signed char>*/           , 0 /*subtract_gpu<int, unsigned short>*/        , 0 /*subtract_gpu<int, short>*/           , subtract_gpu<int, int>              , subtract_gpu<int, float>              , subtract_gpu<int, double>              },
-        {0 /*subtract_gpu<float, unsigned char>*/         , 0 /*subtract_gpu<float, signed char>*/         , 0 /*subtract_gpu<float, unsigned short>*/      , 0 /*subtract_gpu<float, short>*/         , 0 /*subtract_gpu<float, int>*/      , subtract_gpu<float, float>            , subtract_gpu<float, double>            },
-        {0 /*subtract_gpu<double, unsigned char>*/        , 0 /*subtract_gpu<double, signed char>*/        , 0 /*subtract_gpu<double, unsigned short>*/     , 0 /*subtract_gpu<double, short>*/        , 0 /*subtract_gpu<double, int>*/     , 0 /*subtract_gpu<double, float>*/     , subtract_gpu<double, double>           }
+        {
+            subScalar<unsigned char, float, unsigned char>,
+            subScalar<unsigned char, float, signed char>,
+            subScalar<unsigned char, float, unsigned short>,
+            subScalar<unsigned char, float, short>,
+            subScalar<unsigned char, float, int>,
+            subScalar<unsigned char, float, float>,
+            subScalar<unsigned char, double, double>
+        },
+        {
+            subScalar<signed char, float, unsigned char>,
+            subScalar<signed char, float, signed char>,
+            subScalar<signed char, float, unsigned short>,
+            subScalar<signed char, float, short>,
+            subScalar<signed char, float, int>,
+            subScalar<signed char, float, float>,
+            subScalar<signed char, double, double>
+        },
+        {
+            0 /*subScalar<unsigned short, float, unsigned char>*/,
+            0 /*subScalar<unsigned short, float, signed char>*/,
+            subScalar<unsigned short, float, unsigned short>,
+            subScalar<unsigned short, float, short>,
+            subScalar<unsigned short, float, int>,
+            subScalar<unsigned short, float, float>,
+            subScalar<unsigned short, double, double>
+        },
+        {
+            0 /*subScalar<short, float, unsigned char>*/,
+            0 /*subScalar<short, float, signed char>*/,
+            subScalar<short, float, unsigned short>,
+            subScalar<short, float, short>,
+            subScalar<short, float, int>,
+            subScalar<short, float, float>,
+            subScalar<short, double, double>
+        },
+        {
+            0 /*subScalar<int, float, unsigned char>*/,
+            0 /*subScalar<int, float, signed char>*/,
+            0 /*subScalar<int, float, unsigned short>*/,
+            0 /*subScalar<int, float, short>*/,
+            subScalar<int, float, int>,
+            subScalar<int, float, float>,
+            subScalar<int, double, double>
+        },
+        {
+            0 /*subScalar<float, float, unsigned char>*/,
+            0 /*subScalar<float, float, signed char>*/,
+            0 /*subScalar<float, float, unsigned short>*/,
+            0 /*subScalar<float, float, short>*/,
+            0 /*subScalar<float, float, int>*/,
+            subScalar<float, float, float>,
+            subScalar<float, double, double>
+        },
+        {
+            0 /*subScalar<double, double, unsigned char>*/,
+            0 /*subScalar<double, double, signed char>*/,
+            0 /*subScalar<double, double, unsigned short>*/,
+            0 /*subScalar<double, double, short>*/,
+            0 /*subScalar<double, double, int>*/,
+            0 /*subScalar<double, double, float>*/,
+            subScalar<double, double, double>
+        }
     };
 
     typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
@@ -547,34 +909,34 @@ void cv::gpu::subtract(const GpuMat& src, const Scalar& sc, GpuMat& dst, const G
     if (dtype < 0)
         dtype = src.depth();
 
-    CV_Assert(src.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src.channels() <= 4);
-    CV_Assert(mask.empty() || (src.channels() == 1 && mask.size() == src.size() && mask.type() == CV_8U));
+    const int sdepth = src.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( cn <= 4 );
+    CV_Assert( mask.empty() || (cn == 1 && mask.size() == src.size() && mask.type() == CV_8U) );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (mask.empty() && dst.type() == src.type())
+    const npp_func_t npp_func = npp_funcs[sdepth][cn - 1];
+    if (ddepth == sdepth && cn > 1 && npp_func != 0)
     {
-        const npp_func_t npp_func = npp_funcs[src.depth()][src.channels() - 1];
-
-        if (npp_func)
-        {
-            npp_func(src, sc, dst, stream);
-            return;
-        }
+        npp_func(src, sc, dst, stream);
+        return;
     }
 
-    CV_Assert(src.channels() == 1);
+    CV_Assert( cn == 1 );
 
-    const func_t func = funcs[src.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
@@ -585,120 +947,215 @@ void cv::gpu::subtract(const GpuMat& src, const Scalar& sc, GpuMat& dst, const G
 ////////////////////////////////////////////////////////////////////////
 // multiply
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    void multiply_gpu(const PtrStepSz<uchar4>& src1, const PtrStepSzf& src2, const PtrStepSz<uchar4>& dst, cudaStream_t stream);
-    void multiply_gpu(const PtrStepSz<short4>& src1, const PtrStepSzf& src2, const PtrStepSz<short4>& dst, cudaStream_t stream);
+    void mulMat_8uc4_32f(PtrStepSz<unsigned int> src1, PtrStepSzf src2, PtrStepSz<unsigned int> dst, cudaStream_t stream);
 
-    template <typename T, typename D>
-    void multiply_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    void mulMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream);
 
-    template <typename T, typename D>
-    void multiply_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-}}}
+    template <typename T, typename S, typename D>
+    void mulMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+}
 
 void cv::gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, double scale, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
     if (src1.type() == CV_8UC4 && src2.type() == CV_32FC1)
     {
-        CV_Assert(src1.size() == src2.size());
+        CV_Assert( src1.size() == src2.size() );
 
         dst.create(src1.size(), src1.type());
 
-        multiply_gpu(static_cast<PtrStepSz<uchar4> >(src1), static_cast<PtrStepSzf>(src2), static_cast<PtrStepSz<uchar4> >(dst), stream);
+        mulMat_8uc4_32f(src1, src2, dst, stream);
     }
     else if (src1.type() == CV_16SC4 && src2.type() == CV_32FC1)
     {
-        CV_Assert(src1.size() == src2.size());
+        CV_Assert( src1.size() == src2.size() );
 
         dst.create(src1.size(), src1.type());
 
-        multiply_gpu(static_cast<PtrStepSz<short4> >(src1), static_cast<PtrStepSzf>(src2), static_cast<PtrStepSz<short4> >(dst), stream);
+        mulMat_16sc4_32f(src1, src2, dst, stream);
     }
     else
     {
-        typedef void (*func_t)(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+        typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
         static const func_t funcs[7][7] =
         {
-            {multiply_gpu<unsigned char, unsigned char>       , 0 /*multiply_gpu<unsigned char, signed char>*/ , multiply_gpu<unsigned char, unsigned short>    , multiply_gpu<unsigned char, short>       , multiply_gpu<unsigned char, int>    , multiply_gpu<unsigned char, float>    , multiply_gpu<unsigned char, double>    },
-            {0 /*multiply_gpu<signed char, unsigned char>*/   , 0 /*multiply_gpu<signed char, signed char>*/   , 0 /*multiply_gpu<signed char, unsigned short>*/, 0 /*multiply_gpu<signed char, short>*/   , 0 /*multiply_gpu<signed char, int>*/, 0 /*multiply_gpu<signed char, float>*/, 0 /*multiply_gpu<signed char, double>*/},
-            {0 /*multiply_gpu<unsigned short, unsigned char>*/, 0 /*multiply_gpu<unsigned short, signed char>*/, multiply_gpu<unsigned short, unsigned short>   , 0 /*multiply_gpu<unsigned short, short>*/, multiply_gpu<unsigned short, int>   , multiply_gpu<unsigned short, float>   , multiply_gpu<unsigned short, double>   },
-            {0 /*multiply_gpu<short, unsigned char>*/         , 0 /*multiply_gpu<short, signed char>*/         , 0 /*multiply_gpu<short, unsigned short>*/      , multiply_gpu<short, short>               , multiply_gpu<short, int>            , multiply_gpu<short, float>            , multiply_gpu<short, double>            },
-            {0 /*multiply_gpu<int, unsigned char>*/           , 0 /*multiply_gpu<int, signed char>*/           , 0 /*multiply_gpu<int, unsigned short>*/        , 0 /*multiply_gpu<int, short>*/           , multiply_gpu<int, int>              , multiply_gpu<int, float>              , multiply_gpu<int, double>              },
-            {0 /*multiply_gpu<float, unsigned char>*/         , 0 /*multiply_gpu<float, signed char>*/         , 0 /*multiply_gpu<float, unsigned short>*/      , 0 /*multiply_gpu<float, short>*/         , 0 /*multiply_gpu<float, int>*/      , multiply_gpu<float, float>            , multiply_gpu<float, double>            },
-            {0 /*multiply_gpu<double, unsigned char>*/        , 0 /*multiply_gpu<double, signed char>*/        , 0 /*multiply_gpu<double, unsigned short>*/     , 0 /*multiply_gpu<double, short>*/        , 0 /*multiply_gpu<double, int>*/     , 0 /*multiply_gpu<double, float>*/     , multiply_gpu<double, double>           }
-        };
-
-        typedef void (*npp_func_t)(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-        static const npp_func_t npp_funcs[] =
-        {
-            NppArithm<CV_8U , nppiMul_8u_C1RSfs >::call,
-            0,
-            NppArithm<CV_16U, nppiMul_16u_C1RSfs>::call,
-            NppArithm<CV_16S, nppiMul_16s_C1RSfs>::call,
-            NppArithm<CV_32S, nppiMul_32s_C1RSfs>::call,
-            NppArithm<CV_32F, nppiMul_32f_C1R   >::call
+            {
+                mulMat<unsigned char, float, unsigned char>,
+                mulMat<unsigned char, float, signed char>,
+                mulMat<unsigned char, float, unsigned short>,
+                mulMat<unsigned char, float, short>,
+                mulMat<unsigned char, float, int>,
+                mulMat<unsigned char, float, float>,
+                mulMat<unsigned char, double, double>
+            },
+            {
+                mulMat<signed char, float, unsigned char>,
+                mulMat<signed char, float, signed char>,
+                mulMat<signed char, float, unsigned short>,
+                mulMat<signed char, float, short>,
+                mulMat<signed char, float, int>,
+                mulMat<signed char, float, float>,
+                mulMat<signed char, double, double>
+            },
+            {
+                0 /*mulMat<unsigned short, float, unsigned char>*/,
+                0 /*mulMat<unsigned short, float, signed char>*/,
+                mulMat<unsigned short, float, unsigned short>,
+                mulMat<unsigned short, float, short>,
+                mulMat<unsigned short, float, int>,
+                mulMat<unsigned short, float, float>,
+                mulMat<unsigned short, double, double>
+            },
+            {
+                0 /*mulMat<short, float, unsigned char>*/,
+                0 /*mulMat<short, float, signed char>*/,
+                mulMat<short, float, unsigned short>,
+                mulMat<short, float, short>,
+                mulMat<short, float, int>,
+                mulMat<short, float, float>,
+                mulMat<short, double, double>
+            },
+            {
+                0 /*mulMat<int, float, unsigned char>*/,
+                0 /*mulMat<int, float, signed char>*/,
+                0 /*mulMat<int, float, unsigned short>*/,
+                0 /*mulMat<int, float, short>*/,
+                mulMat<int, float, int>,
+                mulMat<int, float, float>,
+                mulMat<int, double, double>
+            },
+            {
+                0 /*mulMat<float, float, unsigned char>*/,
+                0 /*mulMat<float, float, signed char>*/,
+                0 /*mulMat<float, float, unsigned short>*/,
+                0 /*mulMat<float, float, short>*/,
+                0 /*mulMat<float, float, int>*/,
+                mulMat<float, float, float>,
+                mulMat<float, double, double>
+            },
+            {
+                0 /*mulMat<double, double, unsigned char>*/,
+                0 /*mulMat<double, double, signed char>*/,
+                0 /*mulMat<double, double, unsigned short>*/,
+                0 /*mulMat<double, double, short>*/,
+                0 /*mulMat<double, double, int>*/,
+                0 /*mulMat<double, double, float>*/,
+                mulMat<double, double, double>
+            }
         };
 
         if (dtype < 0)
             dtype = src1.depth();
 
-        CV_Assert(src1.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-        CV_Assert(src1.type() == src2.type() && src1.size() == src2.size());
+        const int sdepth = src1.depth();
+        const int ddepth = CV_MAT_DEPTH(dtype);
+        const int cn = src1.channels();
 
-        if (src1.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+        CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+        CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+
+        if (sdepth == CV_64F || ddepth == CV_64F)
         {
-            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+            if (!deviceSupports(NATIVE_DOUBLE))
                 CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
         }
 
-        dst.create(src1.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src1.channels()));
+        dst.create(src1.size(), CV_MAKE_TYPE(ddepth, cn));
 
-#if (CUDA_VERSION <= 4020)
-        if (scale == 1 && dst.type() == src1.type() && src1.depth() <= CV_32F)
-#else
-        if (scale == 1 && dst.type() == src1.type() && src1.depth() <= CV_32F && src1.depth() > CV_8U)
-#endif
-        {
-            npp_funcs[src1.depth()](src1.reshape(1), src2.reshape(1), dst.reshape(1), stream);
-            return;
-        }
+        PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+        PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+        PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
 
-        const func_t func = funcs[src1.depth()][dst.depth()];
+        const func_t func = funcs[sdepth][ddepth];
 
         if (!func)
             CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-        func(src1.reshape(1), src2.reshape(1), dst.reshape(1), scale, stream);
+        func(src1_, src2_, dst_, scale, stream);
     }
 }
 
-namespace
+namespace arithm
 {
-    inline bool isIntScalar(Scalar sc)
-    {
-        return sc.val[0] == static_cast<int>(sc.val[0]) && sc.val[1] == static_cast<int>(sc.val[1]) && sc.val[2] == static_cast<int>(sc.val[2]) && sc.val[3] == static_cast<int>(sc.val[3]);
-    }
+    template <typename T, typename S, typename D>
+    void mulScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 }
 
 void cv::gpu::multiply(const GpuMat& src, const Scalar& sc, GpuMat& dst, double scale, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {multiply_gpu<unsigned char, unsigned char>       , 0 /*multiply_gpu<unsigned char, signed char>*/ , multiply_gpu<unsigned char, unsigned short>    , multiply_gpu<unsigned char, short>       , multiply_gpu<unsigned char, int>    , multiply_gpu<unsigned char, float>    , multiply_gpu<unsigned char, double>    },
-        {0 /*multiply_gpu<signed char, unsigned char>*/   , 0 /*multiply_gpu<signed char, signed char>*/   , 0 /*multiply_gpu<signed char, unsigned short>*/, 0 /*multiply_gpu<signed char, short>*/   , 0 /*multiply_gpu<signed char, int>*/, 0 /*multiply_gpu<signed char, float>*/, 0 /*multiply_gpu<signed char, double>*/},
-        {0 /*multiply_gpu<unsigned short, unsigned char>*/, 0 /*multiply_gpu<unsigned short, signed char>*/, multiply_gpu<unsigned short, unsigned short>   , 0 /*multiply_gpu<unsigned short, short>*/, multiply_gpu<unsigned short, int>   , multiply_gpu<unsigned short, float>   , multiply_gpu<unsigned short, double>   },
-        {0 /*multiply_gpu<short, unsigned char>*/         , 0 /*multiply_gpu<short, signed char>*/         , 0 /*multiply_gpu<short, unsigned short>*/      , multiply_gpu<short, short>               , multiply_gpu<short, int>            , multiply_gpu<short, float>            , multiply_gpu<short, double>            },
-        {0 /*multiply_gpu<int, unsigned char>*/           , 0 /*multiply_gpu<int, signed char>*/           , 0 /*multiply_gpu<int, unsigned short>*/        , 0 /*multiply_gpu<int, short>*/           , multiply_gpu<int, int>              , multiply_gpu<int, float>              , multiply_gpu<int, double>              },
-        {0 /*multiply_gpu<float, unsigned char>*/         , 0 /*multiply_gpu<float, signed char>*/         , 0 /*multiply_gpu<float, unsigned short>*/      , 0 /*multiply_gpu<float, short>*/         , 0 /*multiply_gpu<float, int>*/      , multiply_gpu<float, float>            , multiply_gpu<float, double>            },
-        {0 /*multiply_gpu<double, unsigned char>*/        , 0 /*multiply_gpu<double, signed char>*/        , 0 /*multiply_gpu<double, unsigned short>*/     , 0 /*multiply_gpu<double, short>*/        , 0 /*multiply_gpu<double, int>*/     , 0 /*multiply_gpu<double, float>*/     , multiply_gpu<double, double>           }
+        {
+            mulScalar<unsigned char, float, unsigned char>,
+            mulScalar<unsigned char, float, signed char>,
+            mulScalar<unsigned char, float, unsigned short>,
+            mulScalar<unsigned char, float, short>,
+            mulScalar<unsigned char, float, int>,
+            mulScalar<unsigned char, float, float>,
+            mulScalar<unsigned char, double, double>
+        },
+        {
+            mulScalar<signed char, float, unsigned char>,
+            mulScalar<signed char, float, signed char>,
+            mulScalar<signed char, float, unsigned short>,
+            mulScalar<signed char, float, short>,
+            mulScalar<signed char, float, int>,
+            mulScalar<signed char, float, float>,
+            mulScalar<signed char, double, double>
+        },
+        {
+            0 /*mulScalar<unsigned short, float, unsigned char>*/,
+            0 /*mulScalar<unsigned short, float, signed char>*/,
+            mulScalar<unsigned short, float, unsigned short>,
+            mulScalar<unsigned short, float, short>,
+            mulScalar<unsigned short, float, int>,
+            mulScalar<unsigned short, float, float>,
+            mulScalar<unsigned short, double, double>
+        },
+        {
+            0 /*mulScalar<short, float, unsigned char>*/,
+            0 /*mulScalar<short, float, signed char>*/,
+            mulScalar<short, float, unsigned short>,
+            mulScalar<short, float, short>,
+            mulScalar<short, float, int>,
+            mulScalar<short, float, float>,
+            mulScalar<short, double, double>
+        },
+        {
+            0 /*mulScalar<int, float, unsigned char>*/,
+            0 /*mulScalar<int, float, signed char>*/,
+            0 /*mulScalar<int, float, unsigned short>*/,
+            0 /*mulScalar<int, float, short>*/,
+            mulScalar<int, float, int>,
+            mulScalar<int, float, float>,
+            mulScalar<int, double, double>
+        },
+        {
+            0 /*mulScalar<float, float, unsigned char>*/,
+            0 /*mulScalar<float, float, signed char>*/,
+            0 /*mulScalar<float, float, unsigned short>*/,
+            0 /*mulScalar<float, float, short>*/,
+            0 /*mulScalar<float, float, int>*/,
+            mulScalar<float, float, float>,
+            mulScalar<float, double, double>
+        },
+        {
+            0 /*mulScalar<double, double, unsigned char>*/,
+            0 /*mulScalar<double, double, signed char>*/,
+            0 /*mulScalar<double, double, unsigned short>*/,
+            0 /*mulScalar<double, double, short>*/,
+            0 /*mulScalar<double, double, int>*/,
+            0 /*mulScalar<double, double, float>*/,
+            mulScalar<double, double, double>
+        }
     };
 
     typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
@@ -716,148 +1173,254 @@ void cv::gpu::multiply(const GpuMat& src, const Scalar& sc, GpuMat& dst, double
     if (dtype < 0)
         dtype = src.depth();
 
-    CV_Assert(src.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src.channels() <= 4);
+    const int sdepth = src.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( cn <= 4 );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (dst.type() == src.type() && scale == 1 && (src.depth() == CV_32F || isIntScalar(sc)))
-    {
-        const npp_func_t npp_func = npp_funcs[src.depth()][src.channels() - 1];
+    const Scalar nsc(sc.val[0] * scale, sc.val[1] * scale, sc.val[2] * scale, sc.val[3] * scale);
 
-        if (npp_func)
-        {
-            npp_func(src, sc, dst, stream);
-            return;
-        }
+    const npp_func_t npp_func = npp_funcs[sdepth][cn - 1];
+    if (ddepth == sdepth && cn > 1 && npp_func != 0)
+    {
+        npp_func(src, nsc, dst, stream);
+        return;
     }
 
-    CV_Assert(src.channels() == 1);
+    CV_Assert( cn == 1 );
 
-    const func_t func = funcs[src.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(src, sc.val[0], dst, scale, stream);
+    func(src, nsc.val[0], dst, stream);
 }
 
 ////////////////////////////////////////////////////////////////////////
 // divide
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    void divide_gpu(const PtrStepSz<uchar4>& src1, const PtrStepSzf& src2, const PtrStepSz<uchar4>& dst, cudaStream_t stream);
-    void divide_gpu(const PtrStepSz<short4>& src1, const PtrStepSzf& src2, const PtrStepSz<short4>& dst, cudaStream_t stream);
+    void divMat_8uc4_32f(PtrStepSz<unsigned int> src1, PtrStepSzf src2, PtrStepSz<unsigned int> dst, cudaStream_t stream);
 
-    template <typename T, typename D>
-    void divide_gpu(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    void divMat_16sc4_32f(PtrStepSz<short4> src1, PtrStepSzf src2, PtrStepSz<short4> dst, cudaStream_t stream);
 
-    template <typename T, typename D>
-    void divide_gpu(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
-
-    template <typename T, typename D>
-    void divide_gpu(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
-}}}
+    template <typename T, typename S, typename D>
+    void divMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
+}
 
 void cv::gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, double scale, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
     if (src1.type() == CV_8UC4 && src2.type() == CV_32FC1)
     {
-        CV_Assert(src1.size() == src2.size());
+        CV_Assert( src1.size() == src2.size() );
 
         dst.create(src1.size(), src1.type());
 
-        divide_gpu(static_cast<PtrStepSz<uchar4> >(src1), static_cast<PtrStepSzf>(src2), static_cast<PtrStepSz<uchar4> >(dst), stream);
+        divMat_8uc4_32f(src1, src2, dst, stream);
     }
     else if (src1.type() == CV_16SC4 && src2.type() == CV_32FC1)
     {
-        CV_Assert(src1.size() == src2.size());
+        CV_Assert( src1.size() == src2.size() );
 
         dst.create(src1.size(), src1.type());
 
-        divide_gpu(static_cast<PtrStepSz<short4> >(src1), static_cast<PtrStepSzf>(src2), static_cast<PtrStepSz<short4> >(dst), stream);
+        divMat_16sc4_32f(src1, src2, dst, stream);
     }
     else
     {
-        typedef void (*func_t)(const PtrStepSzb& src1, const PtrStepSzb& src2, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+        typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, double scale, cudaStream_t stream);
         static const func_t funcs[7][7] =
         {
-            {divide_gpu<unsigned char, unsigned char>       , 0 /*divide_gpu<unsigned char, signed char>*/ , divide_gpu<unsigned char, unsigned short>    , divide_gpu<unsigned char, short>       , divide_gpu<unsigned char, int>    , divide_gpu<unsigned char, float>    , divide_gpu<unsigned char, double>    },
-            {0 /*divide_gpu<signed char, unsigned char>*/   , 0 /*divide_gpu<signed char, signed char>*/   , 0 /*divide_gpu<signed char, unsigned short>*/, 0 /*divide_gpu<signed char, short>*/   , 0 /*divide_gpu<signed char, int>*/, 0 /*divide_gpu<signed char, float>*/, 0 /*divide_gpu<signed char, double>*/},
-            {0 /*divide_gpu<unsigned short, unsigned char>*/, 0 /*divide_gpu<unsigned short, signed char>*/, divide_gpu<unsigned short, unsigned short>   , 0 /*divide_gpu<unsigned short, short>*/, divide_gpu<unsigned short, int>   , divide_gpu<unsigned short, float>   , divide_gpu<unsigned short, double>   },
-            {0 /*divide_gpu<short, unsigned char>*/         , 0 /*divide_gpu<short, signed char>*/         , 0 /*divide_gpu<short, unsigned short>*/      , divide_gpu<short, short>               , divide_gpu<short, int>            , divide_gpu<short, float>            , divide_gpu<short, double>            },
-            {0 /*divide_gpu<int, unsigned char>*/           , 0 /*divide_gpu<int, signed char>*/           , 0 /*divide_gpu<int, unsigned short>*/        , 0 /*divide_gpu<int, short>*/           , divide_gpu<int, int>              , divide_gpu<int, float>              , divide_gpu<int, double>              },
-            {0 /*divide_gpu<float, unsigned char>*/         , 0 /*divide_gpu<float, signed char>*/         , 0 /*divide_gpu<float, unsigned short>*/      , 0 /*divide_gpu<float, short>*/         , 0 /*divide_gpu<float, int>*/      , divide_gpu<float, float>            , divide_gpu<float, double>            },
-            {0 /*divide_gpu<double, unsigned char>*/        , 0 /*divide_gpu<double, signed char>*/        , 0 /*divide_gpu<double, unsigned short>*/     , 0 /*divide_gpu<double, short>*/        , 0 /*divide_gpu<double, int>*/     , 0 /*divide_gpu<double, float>*/     , divide_gpu<double, double>           }
-        };
-
-        typedef void (*npp_func_t)(const PtrStepSzb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-        static const npp_func_t npp_funcs[6] =
-        {
-            NppArithm<CV_8U , nppiDiv_8u_C1RSfs >::call,
-            0,
-            NppArithm<CV_16U, nppiDiv_16u_C1RSfs>::call,
-            NppArithm<CV_16S, nppiDiv_16s_C1RSfs>::call,
-            NppArithm<CV_32S, nppiDiv_32s_C1RSfs>::call,
-            NppArithm<CV_32F, nppiDiv_32f_C1R   >::call
+            {
+                divMat<unsigned char, float, unsigned char>,
+                divMat<unsigned char, float, signed char>,
+                divMat<unsigned char, float, unsigned short>,
+                divMat<unsigned char, float, short>,
+                divMat<unsigned char, float, int>,
+                divMat<unsigned char, float, float>,
+                divMat<unsigned char, double, double>
+            },
+            {
+                divMat<signed char, float, unsigned char>,
+                divMat<signed char, float, signed char>,
+                divMat<signed char, float, unsigned short>,
+                divMat<signed char, float, short>,
+                divMat<signed char, float, int>,
+                divMat<signed char, float, float>,
+                divMat<signed char, double, double>
+            },
+            {
+                0 /*divMat<unsigned short, float, unsigned char>*/,
+                0 /*divMat<unsigned short, float, signed char>*/,
+                divMat<unsigned short, float, unsigned short>,
+                divMat<unsigned short, float, short>,
+                divMat<unsigned short, float, int>,
+                divMat<unsigned short, float, float>,
+                divMat<unsigned short, double, double>
+            },
+            {
+                0 /*divMat<short, float, unsigned char>*/,
+                0 /*divMat<short, float, signed char>*/,
+                divMat<short, float, unsigned short>,
+                divMat<short, float, short>,
+                divMat<short, float, int>,
+                divMat<short, float, float>,
+                divMat<short, double, double>
+            },
+            {
+                0 /*divMat<int, float, unsigned char>*/,
+                0 /*divMat<int, float, signed char>*/,
+                0 /*divMat<int, float, unsigned short>*/,
+                0 /*divMat<int, float, short>*/,
+                divMat<int, float, int>,
+                divMat<int, float, float>,
+                divMat<int, double, double>
+            },
+            {
+                0 /*divMat<float, float, unsigned char>*/,
+                0 /*divMat<float, float, signed char>*/,
+                0 /*divMat<float, float, unsigned short>*/,
+                0 /*divMat<float, float, short>*/,
+                0 /*divMat<float, float, int>*/,
+                divMat<float, float, float>,
+                divMat<float, double, double>
+            },
+            {
+                0 /*divMat<double, double, unsigned char>*/,
+                0 /*divMat<double, double, signed char>*/,
+                0 /*divMat<double, double, unsigned short>*/,
+                0 /*divMat<double, double, short>*/,
+                0 /*divMat<double, double, int>*/,
+                0 /*divMat<double, double, float>*/,
+                divMat<double, double, double>
+            }
         };
 
         if (dtype < 0)
             dtype = src1.depth();
 
-        CV_Assert(src1.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-        CV_Assert(src1.type() == src2.type() && src1.size() == src2.size());
+        const int sdepth = src1.depth();
+        const int ddepth = CV_MAT_DEPTH(dtype);
+        const int cn = src1.channels();
 
-        if (src1.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+        CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+        CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+
+        if (sdepth == CV_64F || ddepth == CV_64F)
         {
-            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+            if (!deviceSupports(NATIVE_DOUBLE))
                 CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
         }
 
-        dst.create(src1.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src1.channels()));
+        dst.create(src1.size(), CV_MAKE_TYPE(ddepth, cn));
 
-        if (scale == 1 && dst.type() == src1.type() && src1.depth() <= CV_32F)
-        {
-            npp_funcs[src1.depth()](src2.reshape(1), src1.reshape(1), dst.reshape(1), stream);
-            return;
-        }
+        PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+        PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+        PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
 
-        const func_t func = funcs[src1.depth()][dst.depth()];
+        const func_t func = funcs[sdepth][ddepth];
 
         if (!func)
             CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-        func(src1.reshape(1), src2.reshape(1), dst.reshape(1), scale, stream);
+        func(src1_, src2_, dst_, scale, stream);
     }
 }
 
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void divScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+}
+
 void cv::gpu::divide(const GpuMat& src, const Scalar& sc, GpuMat& dst, double scale, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb& src1, double val, const PtrStepSzb& dst, double scale, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {divide_gpu<unsigned char, unsigned char>       , 0 /*divide_gpu<unsigned char, signed char>*/ , divide_gpu<unsigned char, unsigned short>    , divide_gpu<unsigned char, short>       , divide_gpu<unsigned char, int>    , divide_gpu<unsigned char, float>    , divide_gpu<unsigned char, double>    },
-        {0 /*divide_gpu<signed char, unsigned char>*/   , 0 /*divide_gpu<signed char, signed char>*/   , 0 /*divide_gpu<signed char, unsigned short>*/, 0 /*divide_gpu<signed char, short>*/   , 0 /*divide_gpu<signed char, int>*/, 0 /*divide_gpu<signed char, float>*/, 0 /*divide_gpu<signed char, double>*/},
-        {0 /*divide_gpu<unsigned short, unsigned char>*/, 0 /*divide_gpu<unsigned short, signed char>*/, divide_gpu<unsigned short, unsigned short>   , 0 /*divide_gpu<unsigned short, short>*/, divide_gpu<unsigned short, int>   , divide_gpu<unsigned short, float>   , divide_gpu<unsigned short, double>   },
-        {0 /*divide_gpu<short, unsigned char>*/         , 0 /*divide_gpu<short, signed char>*/         , 0 /*divide_gpu<short, unsigned short>*/      , divide_gpu<short, short>               , divide_gpu<short, int>            , divide_gpu<short, float>            , divide_gpu<short, double>            },
-        {0 /*divide_gpu<int, unsigned char>*/           , 0 /*divide_gpu<int, signed char>*/           , 0 /*divide_gpu<int, unsigned short>*/        , 0 /*divide_gpu<int, short>*/           , divide_gpu<int, int>              , divide_gpu<int, float>              , divide_gpu<int, double>              },
-        {0 /*divide_gpu<float, unsigned char>*/         , 0 /*divide_gpu<float, signed char>*/         , 0 /*divide_gpu<float, unsigned short>*/      , 0 /*divide_gpu<float, short>*/         , 0 /*divide_gpu<float, int>*/      , divide_gpu<float, float>            , divide_gpu<float, double>            },
-        {0 /*divide_gpu<double, unsigned char>*/        , 0 /*divide_gpu<double, signed char>*/        , 0 /*divide_gpu<double, unsigned short>*/     , 0 /*divide_gpu<double, short>*/        , 0 /*divide_gpu<double, int>*/     , 0 /*divide_gpu<double, float>*/     , divide_gpu<double, double>           }
+        {
+            divScalar<unsigned char, float, unsigned char>,
+            divScalar<unsigned char, float, signed char>,
+            divScalar<unsigned char, float, unsigned short>,
+            divScalar<unsigned char, float, short>,
+            divScalar<unsigned char, float, int>,
+            divScalar<unsigned char, float, float>,
+            divScalar<unsigned char, double, double>
+        },
+        {
+            divScalar<signed char, float, unsigned char>,
+            divScalar<signed char, float, signed char>,
+            divScalar<signed char, float, unsigned short>,
+            divScalar<signed char, float, short>,
+            divScalar<signed char, float, int>,
+            divScalar<signed char, float, float>,
+            divScalar<signed char, double, double>
+        },
+        {
+            0 /*divScalar<unsigned short, float, unsigned char>*/,
+            0 /*divScalar<unsigned short, float, signed char>*/,
+            divScalar<unsigned short, float, unsigned short>,
+            divScalar<unsigned short, float, short>,
+            divScalar<unsigned short, float, int>,
+            divScalar<unsigned short, float, float>,
+            divScalar<unsigned short, double, double>
+        },
+        {
+            0 /*divScalar<short, float, unsigned char>*/,
+            0 /*divScalar<short, float, signed char>*/,
+            divScalar<short, float, unsigned short>,
+            divScalar<short, float, short>,
+            divScalar<short, float, int>,
+            divScalar<short, float, float>,
+            divScalar<short, double, double>
+        },
+        {
+            0 /*divScalar<int, float, unsigned char>*/,
+            0 /*divScalar<int, float, signed char>*/,
+            0 /*divScalar<int, float, unsigned short>*/,
+            0 /*divScalar<int, float, short>*/,
+            divScalar<int, float, int>,
+            divScalar<int, float, float>,
+            divScalar<int, double, double>
+        },
+        {
+            0 /*divScalar<float, float, unsigned char>*/,
+            0 /*divScalar<float, float, signed char>*/,
+            0 /*divScalar<float, float, unsigned short>*/,
+            0 /*divScalar<float, float, short>*/,
+            0 /*divScalar<float, float, int>*/,
+            divScalar<float, float, float>,
+            divScalar<float, double, double>
+        },
+        {
+            0 /*divScalar<double, double, unsigned char>*/,
+            0 /*divScalar<double, double, signed char>*/,
+            0 /*divScalar<double, double, unsigned short>*/,
+            0 /*divScalar<double, double, short>*/,
+            0 /*divScalar<double, double, int>*/,
+            0 /*divScalar<double, double, float>*/,
+            divScalar<double, double, double>
+        }
     };
 
     typedef void (*npp_func_t)(const PtrStepSzb src, Scalar sc, PtrStepb dst, cudaStream_t stream);
@@ -875,536 +1438,547 @@ void cv::gpu::divide(const GpuMat& src, const Scalar& sc, GpuMat& dst, double sc
     if (dtype < 0)
         dtype = src.depth();
 
-    CV_Assert(src.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src.channels() <= 4);
+    const int sdepth = src.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( cn <= 4 );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    if (dst.type() == src.type() && scale == 1 && (src.depth() == CV_32F || isIntScalar(sc)))
-    {
-        const npp_func_t npp_func = npp_funcs[src.depth()][src.channels() - 1];
+    const Scalar nsc(sc.val[0] / scale, sc.val[1] / scale, sc.val[2] / scale, sc.val[3] / scale);
 
-        if (npp_func)
-        {
-            npp_func(src, sc, dst, stream);
-            return;
-        }
+    const npp_func_t npp_func = npp_funcs[sdepth][cn - 1];
+    if (ddepth == sdepth && cn > 1 && npp_func != 0)
+    {
+        npp_func(src, nsc, dst, stream);
+        return;
     }
 
-    CV_Assert(src.channels() == 1);
+    CV_Assert( cn == 1 );
 
-    const func_t func = funcs[src.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(src, sc.val[0], dst, scale, stream);
+    func(src, nsc.val[0], dst, stream);
+}
+
+namespace arithm
+{
+    template <typename T, typename S, typename D>
+    void divInv(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 }
 
 void cv::gpu::divide(double scale, const GpuMat& src, GpuMat& dst, int dtype, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(double scalar, const PtrStepSzb& src2, const PtrStepSzb& dst, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][7] =
     {
-        {divide_gpu<unsigned char, unsigned char>       , 0 /*divide_gpu<unsigned char, signed char>*/ , divide_gpu<unsigned char, unsigned short>    , divide_gpu<unsigned char, short>       , divide_gpu<unsigned char, int>    , divide_gpu<unsigned char, float>    , divide_gpu<unsigned char, double>    },
-        {0 /*divide_gpu<signed char, unsigned char>*/   , 0 /*divide_gpu<signed char, signed char>*/   , 0 /*divide_gpu<signed char, unsigned short>*/, 0 /*divide_gpu<signed char, short>*/   , 0 /*divide_gpu<signed char, int>*/, 0 /*divide_gpu<signed char, float>*/, 0 /*divide_gpu<signed char, double>*/},
-        {0 /*divide_gpu<unsigned short, unsigned char>*/, 0 /*divide_gpu<unsigned short, signed char>*/, divide_gpu<unsigned short, unsigned short>   , 0 /*divide_gpu<unsigned short, short>*/, divide_gpu<unsigned short, int>   , divide_gpu<unsigned short, float>   , divide_gpu<unsigned short, double>   },
-        {0 /*divide_gpu<short, unsigned char>*/         , 0 /*divide_gpu<short, signed char>*/         , 0 /*divide_gpu<short, unsigned short>*/      , divide_gpu<short, short>               , divide_gpu<short, int>            , divide_gpu<short, float>            , divide_gpu<short, double>            },
-        {0 /*divide_gpu<int, unsigned char>*/           , 0 /*divide_gpu<int, signed char>*/           , 0 /*divide_gpu<int, unsigned short>*/        , 0 /*divide_gpu<int, short>*/           , divide_gpu<int, int>              , divide_gpu<int, float>              , divide_gpu<int, double>              },
-        {0 /*divide_gpu<float, unsigned char>*/         , 0 /*divide_gpu<float, signed char>*/         , 0 /*divide_gpu<float, unsigned short>*/      , 0 /*divide_gpu<float, short>*/         , 0 /*divide_gpu<float, int>*/      , divide_gpu<float, float>            , divide_gpu<float, double>            },
-        {0 /*divide_gpu<double, unsigned char>*/        , 0 /*divide_gpu<double, signed char>*/        , 0 /*divide_gpu<double, unsigned short>*/     , 0 /*divide_gpu<double, short>*/        , 0 /*divide_gpu<double, int>*/     , 0 /*divide_gpu<double, float>*/     , divide_gpu<double, double>           }
+        {
+            divInv<unsigned char, float, unsigned char>,
+            divInv<unsigned char, float, signed char>,
+            divInv<unsigned char, float, unsigned short>,
+            divInv<unsigned char, float, short>,
+            divInv<unsigned char, float, int>,
+            divInv<unsigned char, float, float>,
+            divInv<unsigned char, double, double>
+        },
+        {
+            divInv<signed char, float, unsigned char>,
+            divInv<signed char, float, signed char>,
+            divInv<signed char, float, unsigned short>,
+            divInv<signed char, float, short>,
+            divInv<signed char, float, int>,
+            divInv<signed char, float, float>,
+            divInv<signed char, double, double>
+        },
+        {
+            0 /*divInv<unsigned short, float, unsigned char>*/,
+            0 /*divInv<unsigned short, float, signed char>*/,
+            divInv<unsigned short, float, unsigned short>,
+            divInv<unsigned short, float, short>,
+            divInv<unsigned short, float, int>,
+            divInv<unsigned short, float, float>,
+            divInv<unsigned short, double, double>
+        },
+        {
+            0 /*divInv<short, float, unsigned char>*/,
+            0 /*divInv<short, float, signed char>*/,
+            divInv<short, float, unsigned short>,
+            divInv<short, float, short>,
+            divInv<short, float, int>,
+            divInv<short, float, float>,
+            divInv<short, double, double>
+        },
+        {
+            0 /*divInv<int, float, unsigned char>*/,
+            0 /*divInv<int, float, signed char>*/,
+            0 /*divInv<int, float, unsigned short>*/,
+            0 /*divInv<int, float, short>*/,
+            divInv<int, float, int>,
+            divInv<int, float, float>,
+            divInv<int, double, double>
+        },
+        {
+            0 /*divInv<float, float, unsigned char>*/,
+            0 /*divInv<float, float, signed char>*/,
+            0 /*divInv<float, float, unsigned short>*/,
+            0 /*divInv<float, float, short>*/,
+            0 /*divInv<float, float, int>*/,
+            divInv<float, float, float>,
+            divInv<float, double, double>
+        },
+        {
+            0 /*divInv<double, double, unsigned char>*/,
+            0 /*divInv<double, double, signed char>*/,
+            0 /*divInv<double, double, unsigned short>*/,
+            0 /*divInv<double, double, short>*/,
+            0 /*divInv<double, double, int>*/,
+            0 /*divInv<double, double, float>*/,
+            divInv<double, double, double>
+        }
     };
 
     if (dtype < 0)
         dtype = src.depth();
 
-    CV_Assert(src.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-    CV_Assert(src.channels() == 1);
+    const int sdepth = src.depth();
+    const int ddepth = CV_MAT_DEPTH(dtype);
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    CV_Assert( sdepth <= CV_64F && ddepth <= CV_64F );
+    CV_Assert( cn == 1 );
+
+    if (sdepth == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_MAT_DEPTH(dtype), src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(ddepth, cn));
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    const func_t func = funcs[src.depth()][dst.depth()];
+    const func_t func = funcs[sdepth][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(scale, src, dst, stream);
+    func(src, scale, dst, stream);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // absdiff
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
     template <typename T>
-    void absdiff_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    void vabsDiff4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
     template <typename T>
-    void absdiff_gpu(const PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
-}}}
+    void vabsDiff2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 
-namespace
-{
-    template <int DEPTH> struct NppAbsDiffFunc
-    {
-        typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* src1, int src1_step, const npp_t* src2, int src2_step, npp_t* dst, int dst_step, NppiSize sz);
-    };
-
-    template <int DEPTH, typename NppAbsDiffFunc<DEPTH>::func_t func> struct NppAbsDiff
-    {
-        typedef typename NppAbsDiffFunc<DEPTH>::npp_t npp_t;
-
-        static void call(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize sz;
-            sz.width  = src1.cols;
-            sz.height = src1.rows;
-
-            nppSafeCall( func((const npp_t*)src1.data, static_cast<int>(src1.step), (const npp_t*)src2.data, static_cast<int>(src2.step),
-                              (npp_t*)dst.data, static_cast<int>(dst.step), sz) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-
-    template <int DEPTH> struct NppAbsDiffCFunc
-    {
-        typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-        typedef npp_t scalar_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc1, int nSrc1Step, npp_t* pDst,  int nDstStep,  NppiSize oSizeROI, npp_t nConstant);
-    };
-    template <> struct NppAbsDiffCFunc<CV_16U>
-    {
-        typedef NppTypeTraits<CV_16U>::npp_t npp_t;
-        typedef Npp32u scalar_t;
-
-#if (CUDA_VERSION <= 4020)
-        typedef NppStatus (*func_t)(const Npp16u* pSrc1, int nSrc1Step, Npp16u* pDst, int nDstStep, NppiSize oSizeROI, Npp32u nConstant);
-#else
-        typedef NppStatus (*func_t)(const Npp16u * pSrc1, int nSrc1Step, Npp16u * pDst,  int nDstStep,  NppiSize oSizeROI, Npp16u nConstant);
-#endif
-    };
-
-    template <int DEPTH, typename NppAbsDiffCFunc<DEPTH>::func_t func> struct NppAbsDiffC
-    {
-        typedef typename NppAbsDiffCFunc<DEPTH>::npp_t npp_t;
-        typedef typename NppAbsDiffCFunc<DEPTH>::scalar_t scalar_t;
-
-        static void call(const PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize sz;
-            sz.width  = src1.cols;
-            sz.height = src1.rows;
-
-            nppSafeCall( func((const npp_t*)src1.data, static_cast<int>(src1.step),
-                              (npp_t*)dst.data, static_cast<int>(dst.step), sz, static_cast<scalar_t>(val)) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+    template <typename T>
+    void absDiffMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
 }
 
-void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream)
+void cv::gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppAbsDiff<CV_8U, nppiAbsDiff_8u_C1R>::call,
-        absdiff_gpu<signed char>,
-        NppAbsDiff<CV_16U, nppiAbsDiff_16u_C1R>::call,
-        absdiff_gpu<short>,
-        absdiff_gpu<int>,
-        NppAbsDiff<CV_32F, nppiAbsDiff_32f_C1R>::call,
-        absdiff_gpu<double>
+        absDiffMat<unsigned char>,
+        absDiffMat<signed char>,
+        absDiffMat<unsigned short>,
+        absDiffMat<short>,
+        absDiffMat<int>,
+        absDiffMat<float>,
+        absDiffMat<double>
+    };
+    static const func_t vfuncs4[] =
+    {
+        vabsDiff4<unsigned int>,
+        vabsDiff4<int>,
+        0,
+        0
+    };
+    static const func_t vfuncs2[] =
+    {
+        0,
+        0,
+        vabsDiff2<unsigned int>,
+        vabsDiff2<int>
     };
 
-    CV_Assert(src1.depth() <= CV_64F);
-    CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
+    const int depth = src1.depth();
+    const int cn = src1.channels();
 
-    if (src1.depth() == CV_64F)
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src1.size(), src1.type());
 
-    funcs[src1.depth()](src1.reshape(1), src2.reshape(1), dst.reshape(1), StreamAccessor::getStream(stream));
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
+
+    if (depth < CV_32S)
+    {
+        const intptr_t src1ptr = reinterpret_cast<intptr_t>(src1_.data);
+        const intptr_t src2ptr = reinterpret_cast<intptr_t>(src2_.data);
+        const intptr_t dstptr = reinterpret_cast<intptr_t>(dst_.data);
+
+        const bool isAllAligned = (src1ptr & 31) == 0 && (src2ptr & 31) == 0 && (dstptr & 31) == 0;
+
+        if (deviceSupports(FEATURE_SET_COMPUTE_20) && isAllAligned)
+        {
+            const func_t vfunc4 = vfuncs4[depth];
+            const func_t vfunc2 = vfuncs2[depth];
+
+            if (vfunc4 != 0 && (src1_.cols & 3) == 0)
+            {
+                const int vcols = src1_.cols >> 2;
+
+                vfunc4(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+
+            if (vfunc2 != 0 && (src1_.cols & 1) == 0)
+            {
+                const int vcols = src1_.cols >> 1;
+
+                vfunc2(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+        }
+    }
+
+    const func_t func = funcs[depth];
+
+    if (!func)
+        CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
+    func(src1_, src2_, dst_, stream);
+}
+
+namespace arithm
+{
+    template <typename T, typename S>
+    void absDiffScalar(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
 }
 
 void cv::gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst, Stream& stream)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, double val, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppAbsDiffC<CV_8U, nppiAbsDiffC_8u_C1R>::call,
-        absdiff_gpu<signed char>,
-        NppAbsDiffC<CV_16U, nppiAbsDiffC_16u_C1R>::call,
-        absdiff_gpu<short>,
-        absdiff_gpu<int>,
-        NppAbsDiffC<CV_32F, nppiAbsDiffC_32f_C1R>::call,
-        absdiff_gpu<double>
+        absDiffScalar<unsigned char, float>,
+        absDiffScalar<signed char, float>,
+        absDiffScalar<unsigned short, float>,
+        absDiffScalar<short, float>,
+        absDiffScalar<int, float>,
+        absDiffScalar<float, float>,
+        absDiffScalar<double, double>
     };
 
-    CV_Assert(src1.depth() <= CV_64F);
-    CV_Assert(src1.channels() == 1);
+    const int depth = src1.depth();
 
-    if (src1.depth() == CV_64F)
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src1.channels() == 1 );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src1.size(), src1.type());
 
-    funcs[src1.depth()](src1, src2.val[0], dst, StreamAccessor::getStream(stream));
+    funcs[depth](src1, src2.val[0], dst, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // abs
 
-void cv::gpu::abs(const GpuMat& src, GpuMat& dst, Stream& s)
+namespace arithm
 {
-    CV_Assert(src.depth() == CV_16S || src.depth() == CV_32F);
+    template <typename T>
+    void absMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
+void cv::gpu::abs(const GpuMat& src, GpuMat& dst, Stream& stream)
+{
+    using namespace arithm;
+
+    typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+    static const func_t funcs[] =
+    {
+        absMat<unsigned char>,
+        absMat<signed char>,
+        absMat<unsigned short>,
+        absMat<short>,
+        absMat<int>,
+        absMat<float>,
+        absMat<double>
+    };
+
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
 
     dst.create(src.size(), src.type());
 
-    cudaStream_t stream = StreamAccessor::getStream(s);
-
-    NppStreamHandler h(stream);
-
-    NppiSize oSizeROI;
-    oSizeROI.width = src.cols * src.channels();
-    oSizeROI.height = src.rows;
-
-    bool aligned = isAligned(src.data, 16) && isAligned(dst.data, 16);
-
-    if (src.depth() == CV_16S)
-    {
-        if (aligned && oSizeROI.width % 4 == 0)
-        {
-            oSizeROI.width /= 4;
-            nppSafeCall( nppiAbs_16s_C4R(src.ptr<Npp16s>(), static_cast<int>(src.step), dst.ptr<Npp16s>(), static_cast<int>(dst.step), oSizeROI) );
-        }
-        else
-        {
-            nppSafeCall( nppiAbs_16s_C1R(src.ptr<Npp16s>(), static_cast<int>(src.step), dst.ptr<Npp16s>(), static_cast<int>(dst.step), oSizeROI) );
-        }
-    }
-    else
-    {
-        if (aligned && oSizeROI.width % 4 == 0)
-        {
-            oSizeROI.width /= 4;
-            nppSafeCall( nppiAbs_32f_C4R(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), oSizeROI) );
-        }
-        else
-        {
-            nppSafeCall( nppiAbs_32f_C1R(src.ptr<Npp32f>(), static_cast<int>(src.step), dst.ptr<Npp32f>(), static_cast<int>(dst.step), oSizeROI) );
-        }
-    }
-
-    if (stream == 0)
-        cudaSafeCall( cudaDeviceSynchronize() );
+    funcs[depth](src, dst, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // sqr
 
-namespace
+namespace arithm
 {
-    template <int DEPTH> struct NppSqrFunc
-    {
-        typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oSizeROI, int nScaleFactor);
-    };
-    template <> struct NppSqrFunc<CV_32F>
-    {
-        typedef NppTypeTraits<CV_32F>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oSizeROI);
-    };
-
-    template <int DEPTH, typename NppSqrFunc<DEPTH>::func_t func, typename NppSqrFunc<DEPTH>::func_t func_c4> struct NppSqr
-    {
-        typedef typename NppSqrFunc<DEPTH>::npp_t npp_t;
-
-        static void call(const GpuMat& src, GpuMat& dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize oSizeROI;
-            oSizeROI.width = src.cols * src.channels();
-            oSizeROI.height = src.rows;
-
-            bool aligned = isAligned(src.data, 16) && isAligned(dst.data, 16);
-
-            if (aligned && oSizeROI.width % 4 == 0)
-            {
-                oSizeROI.width /= 4;
-                nppSafeCall( func_c4(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI, 0) );
-            }
-            else
-            {
-                nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI, 0) );
-            }
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template <typename NppSqrFunc<CV_32F>::func_t func, typename NppSqrFunc<CV_32F>::func_t func_c4> struct NppSqr<CV_32F, func, func_c4>
-    {
-        typedef NppSqrFunc<CV_32F>::npp_t npp_t;
-
-        static void call(const GpuMat& src, GpuMat& dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize oSizeROI;
-            oSizeROI.width = src.cols * src.channels();
-            oSizeROI.height = src.rows;
-
-            bool aligned = isAligned(src.data, 16) && isAligned(dst.data, 16);
-
-            if (aligned && oSizeROI.width % 4 == 0)
-            {
-                oSizeROI.width /= 4;
-                nppSafeCall( func_c4(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI) );
-            }
-            else
-            {
-                nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI) );
-            }
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+    template <typename T>
+    void sqrMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
 }
 
 void cv::gpu::sqr(const GpuMat& src, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const GpuMat& src, GpuMat& dst, cudaStream_t stream);
+    using namespace arithm;
 
+    typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppSqr<CV_8U, nppiSqr_8u_C1RSfs, nppiSqr_8u_C4RSfs>::call,
-        0,
-        NppSqr<CV_16U, nppiSqr_16u_C1RSfs, nppiSqr_16u_C4RSfs>::call,
-        NppSqr<CV_16S, nppiSqr_16s_C1RSfs, nppiSqr_16s_C4RSfs>::call,
-        0,
-        NppSqr<CV_32F, nppiSqr_32f_C1R, nppiSqr_32f_C4R>::call
+        sqrMat<unsigned char>,
+        sqrMat<signed char>,
+        sqrMat<unsigned short>,
+        sqrMat<short>,
+        sqrMat<int>,
+        sqrMat<float>,
+        sqrMat<double>
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_16S || src.depth() == CV_32F);
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, dst, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // sqrt
 
-namespace
+namespace arithm
 {
-    template <int DEPTH> struct NppOneSourceFunc
-    {
-        typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oSizeROI, int nScaleFactor);
-    };
-    template <> struct NppOneSourceFunc<CV_32F>
-    {
-        typedef NppTypeTraits<CV_32F>::npp_t npp_t;
-
-        typedef NppStatus (*func_t)(const npp_t* pSrc, int nSrcStep, npp_t* pDst, int nDstStep, NppiSize oSizeROI);
-    };
-
-    template <int DEPTH, typename NppOneSourceFunc<DEPTH>::func_t func> struct NppOneSource
-    {
-        typedef typename NppOneSourceFunc<DEPTH>::npp_t npp_t;
-
-        static void call(const GpuMat& src, GpuMat& dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize oSizeROI;
-            oSizeROI.width = src.cols * src.channels();
-            oSizeROI.height = src.rows;
-
-            nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI, 0) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
-    template <typename NppOneSourceFunc<CV_32F>::func_t func> struct NppOneSource<CV_32F, func>
-    {
-        typedef NppOneSourceFunc<CV_32F>::npp_t npp_t;
-
-        static void call(const GpuMat& src, GpuMat& dst, cudaStream_t stream)
-        {
-            NppStreamHandler h(stream);
-
-            NppiSize oSizeROI;
-            oSizeROI.width = src.cols * src.channels();
-            oSizeROI.height = src.rows;
-
-            nppSafeCall( func(src.ptr<npp_t>(), static_cast<int>(src.step), dst.ptr<npp_t>(), static_cast<int>(dst.step), oSizeROI) );
-
-            if (stream == 0)
-                cudaSafeCall( cudaDeviceSynchronize() );
-        }
-    };
+    template <typename T>
+    void sqrtMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
 }
 
 void cv::gpu::sqrt(const GpuMat& src, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const GpuMat& src, GpuMat& dst, cudaStream_t stream);
+    using namespace arithm;
 
+    typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppOneSource<CV_8U, nppiSqrt_8u_C1RSfs>::call,
-        0,
-        NppOneSource<CV_16U, nppiSqrt_16u_C1RSfs>::call,
-        NppOneSource<CV_16S, nppiSqrt_16s_C1RSfs>::call,
-        0,
-        NppOneSource<CV_32F, nppiSqrt_32f_C1R>::call
+        sqrtMat<unsigned char>,
+        sqrtMat<signed char>,
+        sqrtMat<unsigned short>,
+        sqrtMat<short>,
+        sqrtMat<int>,
+        sqrtMat<float>,
+        sqrtMat<double>
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_16S || src.depth() == CV_32F);
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, dst, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
 // log
 
+namespace arithm
+{
+    template <typename T>
+    void logMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
 void cv::gpu::log(const GpuMat& src, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const GpuMat& src, GpuMat& dst, cudaStream_t stream);
+    using namespace arithm;
 
+    typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppOneSource<CV_8U, nppiLn_8u_C1RSfs>::call,
-        0,
-        NppOneSource<CV_16U, nppiLn_16u_C1RSfs>::call,
-        NppOneSource<CV_16S, nppiLn_16s_C1RSfs>::call,
-        0,
-        NppOneSource<CV_32F, nppiLn_32f_C1R>::call
+        logMat<unsigned char>,
+        logMat<signed char>,
+        logMat<unsigned short>,
+        logMat<short>,
+        logMat<int>,
+        logMat<float>,
+        logMat<double>
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_16S || src.depth() == CV_32F);
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, dst, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
 // exp
 
+namespace arithm
+{
+    template <typename T>
+    void expMat(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
+}
+
 void cv::gpu::exp(const GpuMat& src, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const GpuMat& src, GpuMat& dst, cudaStream_t stream);
+    using namespace arithm;
 
+    typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        NppOneSource<CV_8U, nppiExp_8u_C1RSfs>::call,
-        0,
-        NppOneSource<CV_16U, nppiExp_16u_C1RSfs>::call,
-        NppOneSource<CV_16S, nppiExp_16s_C1RSfs>::call,
-        0,
-        NppOneSource<CV_32F, nppiExp_32f_C1R>::call
+        expMat<unsigned char>,
+        expMat<signed char>,
+        expMat<unsigned short>,
+        expMat<short>,
+        expMat<int>,
+        expMat<float>,
+        expMat<double>
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_16S || src.depth() == CV_32F);
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, dst, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// Comparison of two matrixes
+// compare
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    template <typename T> void compare_eq(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_ne(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_lt(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_le(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpMatEq(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpMatNe(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpMatLt(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpMatLe(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+}
 
-    template <typename T> void compare_eq(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_ne(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_lt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_le(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_gt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void compare_ge(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
-}}}
-
-void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop, Stream& stream)
+void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
     typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][4] =
     {
-        {compare_eq<unsigned char> , compare_ne<unsigned char> , compare_lt<unsigned char> , compare_le<unsigned char> },
-        {compare_eq<signed char>   , compare_ne<signed char>   , compare_lt<signed char>   , compare_le<signed char>   },
-        {compare_eq<unsigned short>, compare_ne<unsigned short>, compare_lt<unsigned short>, compare_le<unsigned short>},
-        {compare_eq<short>         , compare_ne<short>         , compare_lt<short>         , compare_le<short>         },
-        {compare_eq<int>           , compare_ne<int>           , compare_lt<int>           , compare_le<int>           },
-        {compare_eq<float>         , compare_ne<float>         , compare_lt<float>         , compare_le<float>         },
-        {compare_eq<double>        , compare_ne<double>        , compare_lt<double>        , compare_le<double>        }
+        {cmpMatEq<unsigned char> , cmpMatNe<unsigned char> , cmpMatLt<unsigned char> , cmpMatLe<unsigned char> },
+        {cmpMatEq<signed char>   , cmpMatNe<signed char>   , cmpMatLt<signed char>   , cmpMatLe<signed char>   },
+        {cmpMatEq<unsigned short>, cmpMatNe<unsigned short>, cmpMatLt<unsigned short>, cmpMatLe<unsigned short>},
+        {cmpMatEq<short>         , cmpMatNe<short>         , cmpMatLt<short>         , cmpMatLe<short>         },
+        {cmpMatEq<int>           , cmpMatNe<int>           , cmpMatLt<int>           , cmpMatLe<int>           },
+        {cmpMatEq<float>         , cmpMatNe<float>         , cmpMatLt<float>         , cmpMatLe<float>         },
+        {cmpMatEq<double>        , cmpMatNe<double>        , cmpMatLt<double>        , cmpMatLe<double>        }
     };
 
-    CV_Assert(src1.depth() <= CV_64F);
-    CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-    CV_Assert(cmpop >= CMP_EQ && cmpop <= CMP_NE);
+    const int depth = src1.depth();
+    const int cn = src1.channels();
 
-    if (src1.depth() == CV_64F)
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.size() == src1.size() && src2.type() == src1.type() );
+    CV_Assert( cmpop >= CMP_EQ && cmpop <= CMP_NE );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
+    dst.create(src1.size(), CV_MAKE_TYPE(CV_8U, cn));
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
     static const int codes[] =
     {
         0, 2, 3, 2, 3, 1
@@ -1418,15 +1992,29 @@ void cv::gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int c
         &src2, &src1, &src1, &src2, &src2, &src2
     };
 
-    dst.create(src1.size(), CV_MAKE_TYPE(CV_8U, src1.channels()));
+    const int code = codes[cmpop];
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, psrc1[cmpop]->data, psrc1[cmpop]->step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, psrc2[cmpop]->data, psrc2[cmpop]->step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
 
-    funcs[src1.depth()][codes[cmpop]](psrc1[cmpop]->reshape(1), psrc2[cmpop]->reshape(1), dst.reshape(1), StreamAccessor::getStream(stream));
+    const func_t func = funcs[depth][code];
+
+    func(src1_, src2_, dst_, stream);
+}
+
+namespace arithm
+{
+    template <typename T> void cmpScalarEq(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpScalarNe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpScalarLt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpScalarLe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpScalarGt(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void cmpScalarGe(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
 }
 
 namespace
 {
-    template <typename T>
-    void castScalar(Scalar& sc)
+    template <typename T> void castScalar(Scalar& sc)
     {
         sc.val[0] = saturate_cast<T>(sc.val[0]);
         sc.val[1] = saturate_cast<T>(sc.val[1]);
@@ -1437,18 +2025,18 @@ namespace
 
 void cv::gpu::compare(const GpuMat& src, Scalar sc, GpuMat& dst, int cmpop, Stream& stream)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
     typedef void (*func_t)(PtrStepSzb src, int cn, double val[4], PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][6] =
     {
-        {compare_eq<unsigned char> , compare_gt<unsigned char> , compare_ge<unsigned char> , compare_lt<unsigned char> , compare_le<unsigned char> , compare_ne<unsigned char> },
-        {compare_eq<signed char>   , compare_gt<signed char>   , compare_ge<signed char>   , compare_lt<signed char>   , compare_le<signed char>   , compare_ne<signed char>   },
-        {compare_eq<unsigned short>, compare_gt<unsigned short>, compare_ge<unsigned short>, compare_lt<unsigned short>, compare_le<unsigned short>, compare_ne<unsigned short>},
-        {compare_eq<short>         , compare_gt<short>         , compare_ge<short>         , compare_lt<short>         , compare_le<short>         , compare_ne<short>         },
-        {compare_eq<int>           , compare_gt<int>           , compare_ge<int>           , compare_lt<int>           , compare_le<int>           , compare_ne<int>           },
-        {compare_eq<float>         , compare_gt<float>         , compare_ge<float>         , compare_lt<float>         , compare_le<float>         , compare_ne<float>         },
-        {compare_eq<double>        , compare_gt<double>        , compare_ge<double>        , compare_lt<double>        , compare_le<double>        , compare_ne<double>        }
+        {cmpScalarEq<unsigned char> , cmpScalarGt<unsigned char> , cmpScalarGe<unsigned char> , cmpScalarLt<unsigned char> , cmpScalarLe<unsigned char> , cmpScalarNe<unsigned char> },
+        {cmpScalarEq<signed char>   , cmpScalarGt<signed char>   , cmpScalarGe<signed char>   , cmpScalarLt<signed char>   , cmpScalarLe<signed char>   , cmpScalarNe<signed char>   },
+        {cmpScalarEq<unsigned short>, cmpScalarGt<unsigned short>, cmpScalarGe<unsigned short>, cmpScalarLt<unsigned short>, cmpScalarLe<unsigned short>, cmpScalarNe<unsigned short>},
+        {cmpScalarEq<short>         , cmpScalarGt<short>         , cmpScalarGe<short>         , cmpScalarLt<short>         , cmpScalarLe<short>         , cmpScalarNe<short>         },
+        {cmpScalarEq<int>           , cmpScalarGt<int>           , cmpScalarGe<int>           , cmpScalarLt<int>           , cmpScalarLe<int>           , cmpScalarNe<int>           },
+        {cmpScalarEq<float>         , cmpScalarGt<float>         , cmpScalarGe<float>         , cmpScalarLt<float>         , cmpScalarLe<float>         , cmpScalarNe<float>         },
+        {cmpScalarEq<double>        , cmpScalarGt<double>        , cmpScalarGe<double>        , cmpScalarLt<double>        , cmpScalarLe<double>        , cmpScalarNe<double>        }
     };
 
     typedef void (*cast_func_t)(Scalar& sc);
@@ -1457,235 +2045,266 @@ void cv::gpu::compare(const GpuMat& src, Scalar sc, GpuMat& dst, int cmpop, Stre
         castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
     };
 
-    CV_Assert(src.depth() <= CV_64F);
-    CV_Assert(src.channels() <= 4);
-    CV_Assert(cmpop >= CMP_EQ && cmpop <= CMP_NE);
+    const int depth = src.depth();
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F)
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( cn <= 4 );
+    CV_Assert( cmpop >= CMP_EQ && cmpop <= CMP_NE );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src.size(), CV_MAKE_TYPE(CV_8U, src.channels()));
+    dst.create(src.size(), CV_MAKE_TYPE(CV_8U, cn));
 
-    cast_func[src.depth()](sc);
+    cast_func[depth](sc);
 
-    funcs[src.depth()][cmpop](src, src.channels(), sc.val, dst, StreamAccessor::getStream(stream));
+    funcs[depth][cmpop](src, cn, sc.val, dst, StreamAccessor::getStream(stream));
 }
 
-
 //////////////////////////////////////////////////////////////////////////////
 // Unary bitwise logical operations
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    void bitwiseNotCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src, PtrStepb dst, cudaStream_t stream);
-
-    template <typename T>
-    void bitwiseMaskNotCaller(int rows, int cols, int cn, const PtrStepb src, const PtrStepb mask, PtrStepb dst, cudaStream_t stream);
-}}}
-
-namespace
-{
-    void bitwiseNotCaller(const GpuMat& src, GpuMat& dst, cudaStream_t stream)
-    {
-        dst.create(src.size(), src.type());
-
-        cv::gpu::device::bitwiseNotCaller(src.rows, src.cols, src.elemSize1(), dst.channels(), src, dst, stream);
-    }
-
-    void bitwiseNotCaller(const GpuMat& src, GpuMat& dst, const GpuMat& mask, cudaStream_t stream)
-    {
-        using namespace cv::gpu::device;
-
-        typedef void (*func_t)(int, int, int, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static func_t funcs[] =
-        {
-            bitwiseMaskNotCaller<unsigned char>, bitwiseMaskNotCaller<unsigned char>,
-            bitwiseMaskNotCaller<unsigned short>, bitwiseMaskNotCaller<unsigned short>,
-            bitwiseMaskNotCaller<unsigned int>, bitwiseMaskNotCaller<unsigned int>,
-            bitwiseMaskNotCaller<unsigned int>
-        };
-
-        CV_Assert(src.depth() <= CV_64F);
-        CV_Assert(mask.type() == CV_8U && mask.size() == src.size());
-
-        dst.create(src.size(), src.type());
-
-        const func_t func = funcs[src.depth()];
-
-        int cn = src.depth() != CV_64F ? src.channels() : src.channels() * (sizeof(double) / sizeof(unsigned int));
-
-        func(src.rows, src.cols, cn, src, mask, dst, stream);
-    }
+    template <typename T> void bitMatNot(PtrStepSzb src, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
 }
 
-void cv::gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, Stream& stream)
+void cv::gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, Stream& s)
 {
-    if (mask.empty())
-        bitwiseNotCaller(src, dst, StreamAccessor::getStream(stream));
+    using namespace arithm;
+
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src.size()) );
+
+    dst.create(src.size(), src.type());
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    const int bcols = src.cols * src.elemSize();
+
+    if ((bcols & 3) == 0)
+    {
+        const int vcols = bcols >> 2;
+
+        bitMatNot<unsigned int>(
+                    PtrStepSzb(src.rows, vcols, src.data, src.step),
+                    PtrStepSzb(src.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
+    else if ((bcols & 1) == 0)
+    {
+        const int vcols = bcols >> 1;
+
+        bitMatNot<unsigned short>(
+                    PtrStepSzb(src.rows, vcols, src.data, src.step),
+                    PtrStepSzb(src.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
     else
-        bitwiseNotCaller(src, dst, mask, StreamAccessor::getStream(stream));
+    {
+        bitMatNot<unsigned short>(
+                    PtrStepSzb(src.rows, bcols, src.data, src.step),
+                    PtrStepSzb(src.rows, bcols, dst.data, dst.step),
+                    mask, stream);
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Binary bitwise logical operations
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    void bitwiseOrCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
+    template <typename T> void bitMatAnd(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template <typename T> void bitMatOr(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+    template <typename T> void bitMatXor(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, PtrStepb mask, cudaStream_t stream);
+}
 
-    template <typename T>
-    void bitwiseMaskOrCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, const PtrStepb mask, PtrStepb dst, cudaStream_t stream);
-
-    void bitwiseAndCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-
-    template <typename T>
-    void bitwiseMaskAndCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, const PtrStepb mask, PtrStepb dst, cudaStream_t stream);
-
-    void bitwiseXorCaller(int rows, int cols, size_t elem_size1, int cn, const PtrStepb src1, const PtrStepb src2, PtrStepb dst, cudaStream_t stream);
-
-    template <typename T>
-    void bitwiseMaskXorCaller(int rows, int cols, int cn, const PtrStepb src1, const PtrStepb src2, const PtrStepb mask, PtrStepb dst, cudaStream_t stream);
-}}}
-
-namespace
+void cv::gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& s)
 {
-    void bitwiseOrCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
+    using namespace arithm;
+
+    const int depth = src1.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.size() == src1.size() && src2.type() == src1.type() );
+    CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src1.size()) );
+
+    dst.create(src1.size(), src1.type());
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    const int bcols = src1.cols * src1.elemSize();
+
+    if ((bcols & 3) == 0)
     {
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
+        const int vcols = bcols >> 2;
 
-        dst.create(src1.size(), src1.type());
-
-        cv::gpu::device::bitwiseOrCaller(dst.rows, dst.cols, dst.elemSize1(), dst.channels(), src1, src2, dst, stream);
+        bitMatAnd<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
     }
-
-    void bitwiseOrCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, cudaStream_t stream)
+    else if ((bcols & 1) == 0)
     {
-        using namespace cv::gpu::device;
+        const int vcols = bcols >> 1;
 
-        typedef void (*func_t)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static func_t funcs[] =
-        {
-            bitwiseMaskOrCaller<unsigned char>, bitwiseMaskOrCaller<unsigned char>,
-            bitwiseMaskOrCaller<unsigned short>, bitwiseMaskOrCaller<unsigned short>,
-            bitwiseMaskOrCaller<unsigned int>, bitwiseMaskOrCaller<unsigned int>,
-            bitwiseMaskOrCaller<unsigned int>
-        };
-
-        CV_Assert(src1.depth() <= CV_64F);
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-        CV_Assert(mask.type() == CV_8U && mask.size() == src1.size());
-
-        dst.create(src1.size(), src1.type());
-
-        const func_t func = funcs[src1.depth()];
-
-        int cn = dst.depth() != CV_64F ? dst.channels() : dst.channels() * (sizeof(double) / sizeof(unsigned int));
-
-        func(dst.rows, dst.cols, cn, src1, src2, mask, dst, stream);
+        bitMatAnd<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
     }
-
-
-    void bitwiseAndCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
+    else
     {
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
 
-        dst.create(src1.size(), src1.type());
-
-        cv::gpu::device::bitwiseAndCaller(dst.rows, dst.cols, dst.elemSize1(), dst.channels(), src1, src2, dst, stream);
-    }
-
-    void bitwiseAndCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, cudaStream_t stream)
-    {
-        using namespace cv::gpu::device;
-
-        typedef void (*func_t)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static func_t funcs[] =
-        {
-            bitwiseMaskAndCaller<unsigned char>, bitwiseMaskAndCaller<unsigned char>,
-            bitwiseMaskAndCaller<unsigned short>, bitwiseMaskAndCaller<unsigned short>,
-            bitwiseMaskAndCaller<unsigned int>, bitwiseMaskAndCaller<unsigned int>,
-            bitwiseMaskAndCaller<unsigned int>
-        };
-
-        CV_Assert(src1.depth() <= CV_64F);
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-        CV_Assert(mask.type() == CV_8U && mask.size() == src1.size());
-
-        dst.create(src1.size(), src1.type());
-
-        const func_t func = funcs[src1.depth()];
-
-        int cn = dst.depth() != CV_64F ? dst.channels() : dst.channels() * (sizeof(double) / sizeof(unsigned int));
-
-        func(dst.rows, dst.cols, cn, src1, src2, mask, dst, stream);
-    }
-
-
-    void bitwiseXorCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, cudaStream_t stream)
-    {
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-
-        dst.create(src1.size(), src1.type());
-
-        cv::gpu::device::bitwiseXorCaller(dst.rows, dst.cols, dst.elemSize1(), dst.channels(), src1, src2, dst, stream);
-    }
-
-    void bitwiseXorCaller(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, cudaStream_t stream)
-    {
-        using namespace cv::gpu::device;
-
-        typedef void (*func_t)(int, int, int, const PtrStepb, const PtrStepb, const PtrStepb, PtrStepb, cudaStream_t);
-        static func_t funcs[] =
-        {
-            bitwiseMaskXorCaller<unsigned char>, bitwiseMaskXorCaller<unsigned char>,
-            bitwiseMaskXorCaller<unsigned short>, bitwiseMaskXorCaller<unsigned short>,
-            bitwiseMaskXorCaller<unsigned int>, bitwiseMaskXorCaller<unsigned int>,
-            bitwiseMaskXorCaller<unsigned int>
-        };
-
-        CV_Assert(src1.depth() <= CV_64F);
-        CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-        CV_Assert(mask.type() == CV_8U && mask.size() == src1.size());
-
-        dst.create(src1.size(), src1.type());
-
-        const func_t func = funcs[src1.depth()];
-
-        int cn = dst.depth() != CV_64F ? dst.channels() : dst.channels() * (sizeof(double) / sizeof(unsigned int));
-
-        func(dst.rows, dst.cols, cn, src1, src2, mask, dst, stream);
+        bitMatAnd<unsigned int>(
+                    PtrStepSzb(src1.rows, bcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, bcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, bcols, dst.data, dst.step),
+                    mask, stream);
     }
 }
 
-void cv::gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
+void cv::gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& s)
 {
-    if (mask.empty())
-        bitwiseOrCaller(src1, src2, dst, StreamAccessor::getStream(stream));
+    using namespace arithm;
+
+    const int depth = src1.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.size() == src1.size() && src2.type() == src1.type() );
+    CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src1.size()) );
+
+    dst.create(src1.size(), src1.type());
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    const int bcols = src1.cols * src1.elemSize();
+
+    if ((bcols & 3) == 0)
+    {
+        const int vcols = bcols >> 2;
+
+        bitMatOr<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
+    else if ((bcols & 1) == 0)
+    {
+        const int vcols = bcols >> 1;
+
+        bitMatOr<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
     else
-        bitwiseOrCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+    {
+
+        bitMatOr<unsigned int>(
+                    PtrStepSzb(src1.rows, bcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, bcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, bcols, dst.data, dst.step),
+                    mask, stream);
+    }
 }
 
-void cv::gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
+void cv::gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& s)
 {
-    if (mask.empty())
-        bitwiseAndCaller(src1, src2, dst, StreamAccessor::getStream(stream));
+    using namespace arithm;
+
+    const int depth = src1.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.size() == src1.size() && src2.type() == src1.type() );
+    CV_Assert( mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src1.size()) );
+
+    dst.create(src1.size(), src1.type());
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    const int bcols = src1.cols * src1.elemSize();
+
+    if ((bcols & 3) == 0)
+    {
+        const int vcols = bcols >> 2;
+
+        bitMatXor<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
+    else if ((bcols & 1) == 0)
+    {
+        const int vcols = bcols >> 1;
+
+        bitMatXor<unsigned int>(
+                    PtrStepSzb(src1.rows, vcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, vcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, vcols, dst.data, dst.step),
+                    mask, stream);
+    }
     else
-        bitwiseAndCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+    {
+
+        bitMatXor<unsigned int>(
+                    PtrStepSzb(src1.rows, bcols, src1.data, src1.step),
+                    PtrStepSzb(src1.rows, bcols, src2.data, src2.step),
+                    PtrStepSzb(src1.rows, bcols, dst.data, dst.step),
+                    mask, stream);
+    }
 }
 
-void cv::gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, Stream& stream)
+//////////////////////////////////////////////////////////////////////////////
+// Binary bitwise logical operations with scalars
+
+namespace arithm
 {
-    if (mask.empty())
-        bitwiseXorCaller(src1, src2, dst, StreamAccessor::getStream(stream));
-    else
-        bitwiseXorCaller(src1, src2, dst, mask, StreamAccessor::getStream(stream));
+    template <typename T> void bitScalarAnd(PtrStepSzb src1, unsigned int src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void bitScalarOr(PtrStepSzb src1, unsigned int src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void bitScalarXor(PtrStepSzb src1, unsigned int src2, PtrStepSzb dst, cudaStream_t stream);
 }
 
 namespace
 {
+    typedef void (*bit_scalar_func_t)(PtrStepSzb src1, unsigned int src2, PtrStepSzb dst, cudaStream_t stream);
+
+    template <bit_scalar_func_t func> struct BitScalar
+    {
+        static void call(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream)
+        {
+            func(src, static_cast<unsigned int>(sc.val[0]), dst, stream);
+        }
+    };
+
+    template <bit_scalar_func_t func> struct BitScalar4
+    {
+        static void call(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream)
+        {
+            Scalar_<unsigned int> isc = sc;
+
+            unsigned int packedVal = 0;
+
+            packedVal |= (isc.val[0] & 0xffff);
+            packedVal |= (isc.val[1] & 0xffff) << 8;
+            packedVal |= (isc.val[2] & 0xffff) << 16;
+            packedVal |= (isc.val[3] & 0xffff) << 24;
+
+            func(src, packedVal, dst, stream);
+        }
+    };
+
     template <int DEPTH, int cn> struct NppBitwiseCFunc
     {
         typedef typename NppTypeTraits<DEPTH>::npp_t npp_t;
@@ -1739,64 +2358,79 @@ namespace
     };
 }
 
-void cv::gpu::bitwise_or(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
-{
-    typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
-    static const func_t funcs[5][4] =
-    {
-        {NppBitwiseC<CV_8U , 1, nppiOrC_8u_C1R >::call, 0, NppBitwiseC<CV_8U , 3, nppiOrC_8u_C3R >::call, NppBitwiseC<CV_8U , 4, nppiOrC_8u_C4R >::call},
-        {0,0,0,0},
-        {NppBitwiseC<CV_16U, 1, nppiOrC_16u_C1R>::call, 0, NppBitwiseC<CV_16U, 3, nppiOrC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiOrC_16u_C4R>::call},
-        {0,0,0,0},
-        {NppBitwiseC<CV_32S, 1, nppiOrC_32s_C1R>::call, 0, NppBitwiseC<CV_32S, 3, nppiOrC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiOrC_32s_C4R>::call}
-    };
-
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32S);
-    CV_Assert(src.channels() == 1 || src.channels() == 3 || src.channels() == 4);
-
-    dst.create(src.size(), src.type());
-
-    funcs[src.depth()][src.channels() - 1](src, sc, dst, StreamAccessor::getStream(stream));
-}
-
 void cv::gpu::bitwise_and(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
 {
+    using namespace arithm;
+
     typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
     static const func_t funcs[5][4] =
     {
-        {NppBitwiseC<CV_8U , 1, nppiAndC_8u_C1R >::call, 0, NppBitwiseC<CV_8U , 3, nppiAndC_8u_C3R >::call, NppBitwiseC<CV_8U , 4, nppiAndC_8u_C4R >::call},
+        {BitScalar< bitScalarAnd<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiAndC_8u_C3R >::call, BitScalar4< bitScalarAnd<unsigned int> >::call},
         {0,0,0,0},
-        {NppBitwiseC<CV_16U, 1, nppiAndC_16u_C1R>::call, 0, NppBitwiseC<CV_16U, 3, nppiAndC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiAndC_16u_C4R>::call},
+        {BitScalar< bitScalarAnd<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiAndC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiAndC_16u_C4R>::call},
         {0,0,0,0},
-        {NppBitwiseC<CV_32S, 1, nppiAndC_32s_C1R>::call, 0, NppBitwiseC<CV_32S, 3, nppiAndC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiAndC_32s_C4R>::call}
+        {BitScalar< bitScalarAnd<unsigned int> >::call  , 0, NppBitwiseC<CV_32S, 3, nppiAndC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiAndC_32s_C4R>::call}
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32S);
-    CV_Assert(src.channels() == 1 || src.channels() == 3 || src.channels() == 4);
+    const int depth = src.depth();
+    const int cn = src.channels();
+
+    CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
+    CV_Assert( cn == 1 || cn == 3 || cn == 4 );
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()][src.channels() - 1](src, sc, dst, StreamAccessor::getStream(stream));
+    funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
+}
+
+void cv::gpu::bitwise_or(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
+{
+    using namespace arithm;
+
+    typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
+    static const func_t funcs[5][4] =
+    {
+        {BitScalar< bitScalarOr<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiOrC_8u_C3R >::call, BitScalar4< bitScalarOr<unsigned int> >::call},
+        {0,0,0,0},
+        {BitScalar< bitScalarOr<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiOrC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiOrC_16u_C4R>::call},
+        {0,0,0,0},
+        {BitScalar< bitScalarOr<unsigned int> >::call  , 0, NppBitwiseC<CV_32S, 3, nppiOrC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiOrC_32s_C4R>::call}
+    };
+
+    const int depth = src.depth();
+    const int cn = src.channels();
+
+    CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
+    CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+
+    dst.create(src.size(), src.type());
+
+    funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::bitwise_xor(const GpuMat& src, const Scalar& sc, GpuMat& dst, Stream& stream)
 {
+    using namespace arithm;
+
     typedef void (*func_t)(const GpuMat& src, Scalar sc, GpuMat& dst, cudaStream_t stream);
     static const func_t funcs[5][4] =
     {
-        {NppBitwiseC<CV_8U , 1, nppiXorC_8u_C1R >::call, 0, NppBitwiseC<CV_8U , 3, nppiXorC_8u_C3R >::call, NppBitwiseC<CV_8U , 4, nppiXorC_8u_C4R >::call},
+        {BitScalar< bitScalarXor<unsigned char> >::call , 0, NppBitwiseC<CV_8U , 3, nppiXorC_8u_C3R >::call, BitScalar4< bitScalarXor<unsigned int> >::call},
         {0,0,0,0},
-        {NppBitwiseC<CV_16U, 1, nppiXorC_16u_C1R>::call, 0, NppBitwiseC<CV_16U, 3, nppiXorC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiXorC_16u_C4R>::call},
+        {BitScalar< bitScalarXor<unsigned short> >::call, 0, NppBitwiseC<CV_16U, 3, nppiXorC_16u_C3R>::call, NppBitwiseC<CV_16U, 4, nppiXorC_16u_C4R>::call},
         {0,0,0,0},
-        {NppBitwiseC<CV_32S, 1, nppiXorC_32s_C1R>::call, 0, NppBitwiseC<CV_32S, 3, nppiXorC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiXorC_32s_C4R>::call}
+        {BitScalar< bitScalarXor<unsigned int> >::call  , 0, NppBitwiseC<CV_32S, 3, nppiXorC_32s_C3R>::call, NppBitwiseC<CV_32S, 4, nppiXorC_32s_C4R>::call}
     };
 
-    CV_Assert(src.depth() == CV_8U || src.depth() == CV_16U || src.depth() == CV_32S);
-    CV_Assert(src.channels() == 1 || src.channels() == 3 || src.channels() == 4);
+    const int depth = src.depth();
+    const int cn = src.channels();
+
+    CV_Assert( depth == CV_8U || depth == CV_16U || depth == CV_32S );
+    CV_Assert( cn == 1 || cn == 3 || cn == 4 );
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()][src.channels() - 1](src, sc, dst, StreamAccessor::getStream(stream));
+    funcs[depth][cn - 1](src, sc, dst, StreamAccessor::getStream(stream));
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1898,91 +2532,226 @@ void cv::gpu::lshift(const GpuMat& src, Scalar_<int> sc, GpuMat& dst, Stream& st
 //////////////////////////////////////////////////////////////////////////////
 // Minimum and maximum operations
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    template <typename T> void min_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void max_gpu(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void vmin4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void vmin2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void minMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void minScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
 
-    template <typename T> void min_gpu(const PtrStepSzb src, T val, PtrStepSzb dst, cudaStream_t stream);
-    template <typename T> void max_gpu(const PtrStepSzb src, T val, PtrStepSzb dst, cudaStream_t stream);
-}}}
-
-void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream)
-{
-    using namespace cv::gpu::device;
-
-    typedef void (*func_t)(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
-    static const func_t funcs[] =
-    {
-        min_gpu<unsigned char>,
-        min_gpu<signed char>,
-        min_gpu<unsigned short>,
-        min_gpu<short>,
-        min_gpu<int>,
-        min_gpu<float>,
-        min_gpu<double>
-    };
-
-    CV_Assert(src1.depth() <= CV_64F);
-    CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
-
-    if (src1.depth() == CV_64F)
-    {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
-            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
-    }
-
-    dst.create(src1.size(), src1.type());
-
-    funcs[src1.depth()](src1.reshape(1), src2.reshape(1), dst.reshape(1), StreamAccessor::getStream(stream));
+    template <typename T> void vmax4(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void vmax2(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void maxMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    template <typename T> void maxScalar(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
 }
 
-void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& stream)
+void cv::gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& s)
 {
-    using namespace cv::gpu::device;
+    using namespace arithm;
 
-    typedef void (*func_t)(const PtrStepSzb src1, const PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        max_gpu<unsigned char>,
-        max_gpu<signed char>,
-        max_gpu<unsigned short>,
-        max_gpu<short>,
-        max_gpu<int>,
-        max_gpu<float>,
-        max_gpu<double>
+        minMat<unsigned char>,
+        minMat<signed char>,
+        minMat<unsigned short>,
+        minMat<short>,
+        minMat<int>,
+        minMat<float>,
+        minMat<double>
+    };
+    static const func_t vfuncs4[] =
+    {
+        vmin4<unsigned int>,
+        vmin4<int>,
+        0,
+        0
+    };
+    static const func_t vfuncs2[] =
+    {
+        0,
+        0,
+        vmin2<unsigned int>,
+        vmin2<int>
     };
 
-    CV_Assert(src1.depth() <= CV_64F);
-    CV_Assert(src1.size() == src2.size() && src1.type() == src2.type());
+    const int depth = src1.depth();
+    const int cn = src1.channels();
 
-    if (src1.depth() == CV_64F)
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src1.size(), src1.type());
 
-    funcs[src1.depth()](src1.reshape(1), src2.reshape(1), dst.reshape(1), StreamAccessor::getStream(stream));
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
+
+    if (depth < CV_32S)
+    {
+        const intptr_t src1ptr = reinterpret_cast<intptr_t>(src1_.data);
+        const intptr_t src2ptr = reinterpret_cast<intptr_t>(src2_.data);
+        const intptr_t dstptr = reinterpret_cast<intptr_t>(dst_.data);
+
+        const bool isAllAligned = (src1ptr & 31) == 0 && (src2ptr & 31) == 0 && (dstptr & 31) == 0;
+
+        if (deviceSupports(FEATURE_SET_COMPUTE_20) && isAllAligned)
+        {
+            const func_t vfunc4 = vfuncs4[depth];
+            const func_t vfunc2 = vfuncs2[depth];
+
+            if (vfunc4 != 0 && (src1_.cols & 3) == 0)
+            {
+                const int vcols = src1_.cols >> 2;
+
+                vfunc4(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+
+            if (vfunc2 != 0 && (src1_.cols & 1) == 0)
+            {
+                const int vcols = src1_.cols >> 1;
+
+                vfunc2(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+        }
+    }
+
+    const func_t func = funcs[depth];
+
+    if (!func)
+        CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
+    func(src1_, src2_, dst_, stream);
+}
+
+void cv::gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, Stream& s)
+{
+    using namespace arithm;
+
+    typedef void (*func_t)(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream);
+    static const func_t funcs[] =
+    {
+        maxMat<unsigned char>,
+        maxMat<signed char>,
+        maxMat<unsigned short>,
+        maxMat<short>,
+        maxMat<int>,
+        maxMat<float>,
+        maxMat<double>
+    };
+    static const func_t vfuncs4[] =
+    {
+        vmax4<unsigned int>,
+        vmax4<int>,
+        0,
+        0
+    };
+    static const func_t vfuncs2[] =
+    {
+        0,
+        0,
+        vmax2<unsigned int>,
+        vmax2<int>
+    };
+
+    const int depth = src1.depth();
+    const int cn = src1.channels();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src2.type() == src1.type() && src2.size() == src1.size() );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
+
+    dst.create(src1.size(), src1.type());
+
+    cudaStream_t stream = StreamAccessor::getStream(s);
+
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
+
+    if (depth < CV_32S)
+    {
+        const intptr_t src1ptr = reinterpret_cast<intptr_t>(src1_.data);
+        const intptr_t src2ptr = reinterpret_cast<intptr_t>(src2_.data);
+        const intptr_t dstptr = reinterpret_cast<intptr_t>(dst_.data);
+
+        const bool isAllAligned = (src1ptr & 31) == 0 && (src2ptr & 31) == 0 && (dstptr & 31) == 0;
+
+        if (deviceSupports(FEATURE_SET_COMPUTE_20) && isAllAligned)
+        {
+            const func_t vfunc4 = vfuncs4[depth];
+            const func_t vfunc2 = vfuncs2[depth];
+
+            if (vfunc4 != 0 && (src1_.cols & 3) == 0)
+            {
+                const int vcols = src1_.cols >> 2;
+
+                vfunc4(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+
+            if (vfunc2 != 0 && (src1_.cols & 1) == 0)
+            {
+                const int vcols = src1_.cols >> 1;
+
+                vfunc2(PtrStepSzb(src1_.rows, vcols, src1_.data, src1_.step),
+                       PtrStepSzb(src1_.rows, vcols, src2_.data, src2_.step),
+                       PtrStepSzb(src1_.rows, vcols, dst_.data, dst_.step),
+                       stream);
+
+                return;
+            }
+        }
+    }
+
+    const func_t func = funcs[depth];
+
+    if (!func)
+        CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
+
+    func(src1_, src2_, dst_, stream);
 }
 
 namespace
 {
-    template <typename T> void minScalar(const PtrStepSzb src, double val, PtrStepSzb dst, cudaStream_t stream)
+    template <typename T> double castScalar(double val)
     {
-        cv::gpu::device::min_gpu(src, saturate_cast<T>(val), dst, stream);
-    }
-
-    template <typename T> void maxScalar(const PtrStepSzb src, double val, PtrStepSzb dst, cudaStream_t stream)
-    {
-        cv::gpu::device::max_gpu(src, saturate_cast<T>(val), dst, stream);
+        return saturate_cast<T>(val);
     }
 }
 
 void cv::gpu::min(const GpuMat& src, double val, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    using namespace arithm;
+
+    typedef void (*func_t)(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
         minScalar<unsigned char>,
@@ -1994,23 +2763,33 @@ void cv::gpu::min(const GpuMat& src, double val, GpuMat& dst, Stream& stream)
         minScalar<double>
     };
 
-    CV_Assert(src.depth() <= CV_64F);
-    CV_Assert(src.channels() == 1);
-
-    if (src.depth() == CV_64F)
+    typedef double (*cast_func_t)(double sc);
+    static const cast_func_t cast_func[] =
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
+    };
+
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, val, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::max(const GpuMat& src, double val, GpuMat& dst, Stream& stream)
 {
-    typedef void (*func_t)(const PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
+    using namespace arithm;
+
+    typedef void (*func_t)(PtrStepSzb src1, double src2, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
         maxScalar<unsigned char>,
@@ -2022,45 +2801,47 @@ void cv::gpu::max(const GpuMat& src, double val, GpuMat& dst, Stream& stream)
         maxScalar<double>
     };
 
-    CV_Assert(src.depth() <= CV_64F);
-    CV_Assert(src.channels() == 1);
-
-    if (src.depth() == CV_64F)
+    typedef double (*cast_func_t)(double sc);
+    static const cast_func_t cast_func[] =
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        castScalar<unsigned char>, castScalar<signed char>, castScalar<unsigned short>, castScalar<short>, castScalar<int>, castScalar<float>, castScalar<double>
+    };
+
+    const int depth = src.depth();
+
+    CV_Assert( depth <= CV_64F );
+    CV_Assert( src.channels() == 1 );
+
+    if (depth == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src, val, dst, StreamAccessor::getStream(stream));
+    funcs[depth](src, cast_func[depth](val), dst, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
 // threshold
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
     template <typename T>
-    void threshold_gpu(const PtrStepSzb& src, const PtrStepSzb& dst, T thresh, T maxVal, int type, cudaStream_t stream);
-}}}
-
-namespace
-{
-    template <typename T> void threshold_caller(const GpuMat& src, GpuMat& dst, double thresh, double maxVal, int type, cudaStream_t stream)
-    {
-        cv::gpu::device::threshold_gpu<T>(src, dst, saturate_cast<T>(thresh), saturate_cast<T>(maxVal), type, stream);
-    }
+    void threshold(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
 }
 
 double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxVal, int type, Stream& s)
 {
-    CV_Assert(src.channels() == 1 && src.depth() <= CV_64F);
-    CV_Assert(type <= THRESH_TOZERO_INV);
+    const int depth = src.depth();
 
-    if (src.depth() == CV_64F)
+    CV_Assert( src.channels() == 1 && depth <= CV_64F );
+    CV_Assert( type <= THRESH_TOZERO_INV );
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
@@ -2084,21 +2865,25 @@ double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double
     }
     else
     {
-        typedef void (*func_t)(const GpuMat& src, GpuMat& dst, double thresh, double maxVal, int type, cudaStream_t stream);
+        typedef void (*func_t)(PtrStepSzb src, PtrStepSzb dst, double thresh, double maxVal, int type, cudaStream_t stream);
         static const func_t funcs[] =
         {
-            threshold_caller<unsigned char>, threshold_caller<signed char>,
-            threshold_caller<unsigned short>, threshold_caller<short>,
-            threshold_caller<int>, threshold_caller<float>, threshold_caller<double>
+            arithm::threshold<unsigned char>,
+            arithm::threshold<signed char>,
+            arithm::threshold<unsigned short>,
+            arithm::threshold<short>,
+            arithm::threshold<int>,
+            arithm::threshold<float>,
+            arithm::threshold<double>
         };
 
-        if (src.depth() != CV_32F && src.depth() != CV_64F)
+        if (depth != CV_32F && depth != CV_64F)
         {
             thresh = cvFloor(thresh);
             maxVal = cvRound(maxVal);
         }
 
-        funcs[src.depth()](src, dst, thresh, maxVal, type, stream);
+        funcs[depth](src, dst, thresh, maxVal, type, stream);
     }
 
     return thresh;
@@ -2107,34 +2892,42 @@ double cv::gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double
 ////////////////////////////////////////////////////////////////////////
 // pow
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
-    template<typename T> void pow_caller(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
-}}}
+    template<typename T> void pow(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
+}
 
 void cv::gpu::pow(const GpuMat& src, double power, GpuMat& dst, Stream& stream)
 {
-    using namespace cv::gpu::device;
-
     typedef void (*func_t)(PtrStepSzb src, double power, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[] =
     {
-        pow_caller<unsigned char>,  pow_caller<signed char>,
-        pow_caller<unsigned short>, pow_caller<short>,
-        pow_caller<int>, pow_caller<float>, pow_caller<double>
+        arithm::pow<unsigned char>,
+        arithm::pow<signed char>,
+        arithm::pow<unsigned short>,
+        arithm::pow<short>,
+        arithm::pow<int>,
+        arithm::pow<float>,
+        arithm::pow<double>
     };
 
-    CV_Assert(src.depth() <= CV_64F);
+    const int depth = src.depth();
+    const int cn = src.channels();
 
-    if (src.depth() == CV_64F)
+    CV_Assert(depth <= CV_64F);
+
+    if (depth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
     dst.create(src.size(), src.type());
 
-    funcs[src.depth()](src.reshape(1), power, dst.reshape(1), StreamAccessor::getStream(stream));
+    PtrStepSzb src_(src.rows, src.cols * cn, src.data, src.step);
+    PtrStepSzb dst_(src.rows, src.cols * cn, dst.data, dst.step);
+
+    funcs[depth](src_, power, dst_, StreamAccessor::getStream(stream));
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -2200,8 +2993,8 @@ void cv::gpu::alphaComp(const GpuMat& img1, const GpuMat& img2, GpuMat& dst, int
         NppAlphaComp<CV_32F, nppiAlphaComp_32f_AC4R>::call
     };
 
-    CV_Assert(img1.type() == CV_8UC4 || img1.type() == CV_16UC4 || img1.type() == CV_32SC4 || img1.type() == CV_32FC4);
-    CV_Assert(img1.size() == img2.size() && img1.type() == img2.type());
+    CV_Assert( img1.type() == CV_8UC4 || img1.type() == CV_16UC4 || img1.type() == CV_32SC4 || img1.type() == CV_32FC4 );
+    CV_Assert( img1.size() == img2.size() && img1.type() == img2.type() );
 
     dst.create(img1.size(), img1.type());
 
@@ -2213,507 +3006,508 @@ void cv::gpu::alphaComp(const GpuMat& img1, const GpuMat& img2, GpuMat& dst, int
 ////////////////////////////////////////////////////////////////////////
 // addWeighted
 
-namespace cv { namespace gpu { namespace device
+namespace arithm
 {
     template <typename T1, typename T2, typename D>
-    void addWeighted_gpu(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-}}}
+    void addWeighted(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
+}
 
-void cv::gpu::addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst, int dtype, Stream& stream)
+void cv::gpu::addWeighted(const GpuMat& src1, double alpha, const GpuMat& src2, double beta, double gamma, GpuMat& dst, int ddepth, Stream& stream)
 {
-    using namespace cv::gpu::device;
-
-    typedef void (*func_t)(const PtrStepSzb& src1, double alpha, const PtrStepSzb& src2, double beta, double gamma, const PtrStepSzb& dst, cudaStream_t stream);
-
+    typedef void (*func_t)(PtrStepSzb src1, double alpha, PtrStepSzb src2, double beta, double gamma, PtrStepSzb dst, cudaStream_t stream);
     static const func_t funcs[7][7][7] =
     {
         {
             {
-                addWeighted_gpu<unsigned char, unsigned char, unsigned char >,
-                addWeighted_gpu<unsigned char, unsigned char, signed char >,
-                addWeighted_gpu<unsigned char, unsigned char, unsigned short>,
-                addWeighted_gpu<unsigned char, unsigned char, short >,
-                addWeighted_gpu<unsigned char, unsigned char, int   >,
-                addWeighted_gpu<unsigned char, unsigned char, float >,
-                addWeighted_gpu<unsigned char, unsigned char, double>
+                arithm::addWeighted<unsigned char, unsigned char, unsigned char >,
+                arithm::addWeighted<unsigned char, unsigned char, signed char >,
+                arithm::addWeighted<unsigned char, unsigned char, unsigned short>,
+                arithm::addWeighted<unsigned char, unsigned char, short >,
+                arithm::addWeighted<unsigned char, unsigned char, int   >,
+                arithm::addWeighted<unsigned char, unsigned char, float >,
+                arithm::addWeighted<unsigned char, unsigned char, double>
             },
             {
-                addWeighted_gpu<unsigned char, signed char, unsigned char >,
-                addWeighted_gpu<unsigned char, signed char, signed char >,
-                addWeighted_gpu<unsigned char, signed char, unsigned short>,
-                addWeighted_gpu<unsigned char, signed char, short >,
-                addWeighted_gpu<unsigned char, signed char, int   >,
-                addWeighted_gpu<unsigned char, signed char, float >,
-                addWeighted_gpu<unsigned char, signed char, double>
+                arithm::addWeighted<unsigned char, signed char, unsigned char >,
+                arithm::addWeighted<unsigned char, signed char, signed char >,
+                arithm::addWeighted<unsigned char, signed char, unsigned short>,
+                arithm::addWeighted<unsigned char, signed char, short >,
+                arithm::addWeighted<unsigned char, signed char, int   >,
+                arithm::addWeighted<unsigned char, signed char, float >,
+                arithm::addWeighted<unsigned char, signed char, double>
             },
             {
-                addWeighted_gpu<unsigned char, unsigned short, unsigned char >,
-                addWeighted_gpu<unsigned char, unsigned short, signed char >,
-                addWeighted_gpu<unsigned char, unsigned short, unsigned short>,
-                addWeighted_gpu<unsigned char, unsigned short, short >,
-                addWeighted_gpu<unsigned char, unsigned short, int   >,
-                addWeighted_gpu<unsigned char, unsigned short, float >,
-                addWeighted_gpu<unsigned char, unsigned short, double>
+                arithm::addWeighted<unsigned char, unsigned short, unsigned char >,
+                arithm::addWeighted<unsigned char, unsigned short, signed char >,
+                arithm::addWeighted<unsigned char, unsigned short, unsigned short>,
+                arithm::addWeighted<unsigned char, unsigned short, short >,
+                arithm::addWeighted<unsigned char, unsigned short, int   >,
+                arithm::addWeighted<unsigned char, unsigned short, float >,
+                arithm::addWeighted<unsigned char, unsigned short, double>
             },
             {
-                addWeighted_gpu<unsigned char, short, unsigned char >,
-                addWeighted_gpu<unsigned char, short, signed char >,
-                addWeighted_gpu<unsigned char, short, unsigned short>,
-                addWeighted_gpu<unsigned char, short, short >,
-                addWeighted_gpu<unsigned char, short, int   >,
-                addWeighted_gpu<unsigned char, short, float >,
-                addWeighted_gpu<unsigned char, short, double>
+                arithm::addWeighted<unsigned char, short, unsigned char >,
+                arithm::addWeighted<unsigned char, short, signed char >,
+                arithm::addWeighted<unsigned char, short, unsigned short>,
+                arithm::addWeighted<unsigned char, short, short >,
+                arithm::addWeighted<unsigned char, short, int   >,
+                arithm::addWeighted<unsigned char, short, float >,
+                arithm::addWeighted<unsigned char, short, double>
             },
             {
-                addWeighted_gpu<unsigned char, int, unsigned char >,
-                addWeighted_gpu<unsigned char, int, signed char >,
-                addWeighted_gpu<unsigned char, int, unsigned short>,
-                addWeighted_gpu<unsigned char, int, short >,
-                addWeighted_gpu<unsigned char, int, int   >,
-                addWeighted_gpu<unsigned char, int, float >,
-                addWeighted_gpu<unsigned char, int, double>
+                arithm::addWeighted<unsigned char, int, unsigned char >,
+                arithm::addWeighted<unsigned char, int, signed char >,
+                arithm::addWeighted<unsigned char, int, unsigned short>,
+                arithm::addWeighted<unsigned char, int, short >,
+                arithm::addWeighted<unsigned char, int, int   >,
+                arithm::addWeighted<unsigned char, int, float >,
+                arithm::addWeighted<unsigned char, int, double>
             },
             {
-                addWeighted_gpu<unsigned char, float, unsigned char >,
-                addWeighted_gpu<unsigned char, float, signed char >,
-                addWeighted_gpu<unsigned char, float, unsigned short>,
-                addWeighted_gpu<unsigned char, float, short >,
-                addWeighted_gpu<unsigned char, float, int   >,
-                addWeighted_gpu<unsigned char, float, float >,
-                addWeighted_gpu<unsigned char, float, double>
+                arithm::addWeighted<unsigned char, float, unsigned char >,
+                arithm::addWeighted<unsigned char, float, signed char >,
+                arithm::addWeighted<unsigned char, float, unsigned short>,
+                arithm::addWeighted<unsigned char, float, short >,
+                arithm::addWeighted<unsigned char, float, int   >,
+                arithm::addWeighted<unsigned char, float, float >,
+                arithm::addWeighted<unsigned char, float, double>
             },
             {
-                addWeighted_gpu<unsigned char, double, unsigned char >,
-                addWeighted_gpu<unsigned char, double, signed char >,
-                addWeighted_gpu<unsigned char, double, unsigned short>,
-                addWeighted_gpu<unsigned char, double, short >,
-                addWeighted_gpu<unsigned char, double, int   >,
-                addWeighted_gpu<unsigned char, double, float >,
-                addWeighted_gpu<unsigned char, double, double>
+                arithm::addWeighted<unsigned char, double, unsigned char >,
+                arithm::addWeighted<unsigned char, double, signed char >,
+                arithm::addWeighted<unsigned char, double, unsigned short>,
+                arithm::addWeighted<unsigned char, double, short >,
+                arithm::addWeighted<unsigned char, double, int   >,
+                arithm::addWeighted<unsigned char, double, float >,
+                arithm::addWeighted<unsigned char, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<signed char, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<signed char, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<signed char, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<signed char, unsigned char, short >*/,
-                0/*addWeighted_gpu<signed char, unsigned char, int   >*/,
-                0/*addWeighted_gpu<signed char, unsigned char, float >*/,
-                0/*addWeighted_gpu<signed char, unsigned char, double>*/
+                0/*arithm::addWeighted<signed char, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<signed char, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<signed char, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<signed char, unsigned char, short >*/,
+                0/*arithm::addWeighted<signed char, unsigned char, int   >*/,
+                0/*arithm::addWeighted<signed char, unsigned char, float >*/,
+                0/*arithm::addWeighted<signed char, unsigned char, double>*/
             },
             {
-                addWeighted_gpu<signed char, signed char, unsigned char >,
-                addWeighted_gpu<signed char, signed char, signed char >,
-                addWeighted_gpu<signed char, signed char, unsigned short>,
-                addWeighted_gpu<signed char, signed char, short >,
-                addWeighted_gpu<signed char, signed char, int   >,
-                addWeighted_gpu<signed char, signed char, float >,
-                addWeighted_gpu<signed char, signed char, double>
+                arithm::addWeighted<signed char, signed char, unsigned char >,
+                arithm::addWeighted<signed char, signed char, signed char >,
+                arithm::addWeighted<signed char, signed char, unsigned short>,
+                arithm::addWeighted<signed char, signed char, short >,
+                arithm::addWeighted<signed char, signed char, int   >,
+                arithm::addWeighted<signed char, signed char, float >,
+                arithm::addWeighted<signed char, signed char, double>
             },
             {
-                addWeighted_gpu<signed char, unsigned short, unsigned char >,
-                addWeighted_gpu<signed char, unsigned short, signed char >,
-                addWeighted_gpu<signed char, unsigned short, unsigned short>,
-                addWeighted_gpu<signed char, unsigned short, short >,
-                addWeighted_gpu<signed char, unsigned short, int   >,
-                addWeighted_gpu<signed char, unsigned short, float >,
-                addWeighted_gpu<signed char, unsigned short, double>
+                arithm::addWeighted<signed char, unsigned short, unsigned char >,
+                arithm::addWeighted<signed char, unsigned short, signed char >,
+                arithm::addWeighted<signed char, unsigned short, unsigned short>,
+                arithm::addWeighted<signed char, unsigned short, short >,
+                arithm::addWeighted<signed char, unsigned short, int   >,
+                arithm::addWeighted<signed char, unsigned short, float >,
+                arithm::addWeighted<signed char, unsigned short, double>
             },
             {
-                addWeighted_gpu<signed char, short, unsigned char >,
-                addWeighted_gpu<signed char, short, signed char >,
-                addWeighted_gpu<signed char, short, unsigned short>,
-                addWeighted_gpu<signed char, short, short >,
-                addWeighted_gpu<signed char, short, int   >,
-                addWeighted_gpu<signed char, short, float >,
-                addWeighted_gpu<signed char, short, double>
+                arithm::addWeighted<signed char, short, unsigned char >,
+                arithm::addWeighted<signed char, short, signed char >,
+                arithm::addWeighted<signed char, short, unsigned short>,
+                arithm::addWeighted<signed char, short, short >,
+                arithm::addWeighted<signed char, short, int   >,
+                arithm::addWeighted<signed char, short, float >,
+                arithm::addWeighted<signed char, short, double>
             },
             {
-                addWeighted_gpu<signed char, int, unsigned char >,
-                addWeighted_gpu<signed char, int, signed char >,
-                addWeighted_gpu<signed char, int, unsigned short>,
-                addWeighted_gpu<signed char, int, short >,
-                addWeighted_gpu<signed char, int, int   >,
-                addWeighted_gpu<signed char, int, float >,
-                addWeighted_gpu<signed char, int, double>
+                arithm::addWeighted<signed char, int, unsigned char >,
+                arithm::addWeighted<signed char, int, signed char >,
+                arithm::addWeighted<signed char, int, unsigned short>,
+                arithm::addWeighted<signed char, int, short >,
+                arithm::addWeighted<signed char, int, int   >,
+                arithm::addWeighted<signed char, int, float >,
+                arithm::addWeighted<signed char, int, double>
             },
             {
-                addWeighted_gpu<signed char, float, unsigned char >,
-                addWeighted_gpu<signed char, float, signed char >,
-                addWeighted_gpu<signed char, float, unsigned short>,
-                addWeighted_gpu<signed char, float, short >,
-                addWeighted_gpu<signed char, float, int   >,
-                addWeighted_gpu<signed char, float, float >,
-                addWeighted_gpu<signed char, float, double>
+                arithm::addWeighted<signed char, float, unsigned char >,
+                arithm::addWeighted<signed char, float, signed char >,
+                arithm::addWeighted<signed char, float, unsigned short>,
+                arithm::addWeighted<signed char, float, short >,
+                arithm::addWeighted<signed char, float, int   >,
+                arithm::addWeighted<signed char, float, float >,
+                arithm::addWeighted<signed char, float, double>
             },
             {
-                addWeighted_gpu<signed char, double, unsigned char >,
-                addWeighted_gpu<signed char, double, signed char >,
-                addWeighted_gpu<signed char, double, unsigned short>,
-                addWeighted_gpu<signed char, double, short >,
-                addWeighted_gpu<signed char, double, int   >,
-                addWeighted_gpu<signed char, double, float >,
-                addWeighted_gpu<signed char, double, double>
+                arithm::addWeighted<signed char, double, unsigned char >,
+                arithm::addWeighted<signed char, double, signed char >,
+                arithm::addWeighted<signed char, double, unsigned short>,
+                arithm::addWeighted<signed char, double, short >,
+                arithm::addWeighted<signed char, double, int   >,
+                arithm::addWeighted<signed char, double, float >,
+                arithm::addWeighted<signed char, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<unsigned short, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, short >*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, int   >*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, float >*/,
-                0/*addWeighted_gpu<unsigned short, unsigned char, double>*/
+                0/*arithm::addWeighted<unsigned short, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, short >*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, int   >*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, float >*/,
+                0/*arithm::addWeighted<unsigned short, unsigned char, double>*/
             },
             {
-                0/*addWeighted_gpu<unsigned short, signed char, unsigned char >*/,
-                0/*addWeighted_gpu<unsigned short, signed char, signed char >*/,
-                0/*addWeighted_gpu<unsigned short, signed char, unsigned short>*/,
-                0/*addWeighted_gpu<unsigned short, signed char, short >*/,
-                0/*addWeighted_gpu<unsigned short, signed char, int   >*/,
-                0/*addWeighted_gpu<unsigned short, signed char, float >*/,
-                0/*addWeighted_gpu<unsigned short, signed char, double>*/
+                0/*arithm::addWeighted<unsigned short, signed char, unsigned char >*/,
+                0/*arithm::addWeighted<unsigned short, signed char, signed char >*/,
+                0/*arithm::addWeighted<unsigned short, signed char, unsigned short>*/,
+                0/*arithm::addWeighted<unsigned short, signed char, short >*/,
+                0/*arithm::addWeighted<unsigned short, signed char, int   >*/,
+                0/*arithm::addWeighted<unsigned short, signed char, float >*/,
+                0/*arithm::addWeighted<unsigned short, signed char, double>*/
             },
             {
-                addWeighted_gpu<unsigned short, unsigned short, unsigned char >,
-                addWeighted_gpu<unsigned short, unsigned short, signed char >,
-                addWeighted_gpu<unsigned short, unsigned short, unsigned short>,
-                addWeighted_gpu<unsigned short, unsigned short, short >,
-                addWeighted_gpu<unsigned short, unsigned short, int   >,
-                addWeighted_gpu<unsigned short, unsigned short, float >,
-                addWeighted_gpu<unsigned short, unsigned short, double>
+                arithm::addWeighted<unsigned short, unsigned short, unsigned char >,
+                arithm::addWeighted<unsigned short, unsigned short, signed char >,
+                arithm::addWeighted<unsigned short, unsigned short, unsigned short>,
+                arithm::addWeighted<unsigned short, unsigned short, short >,
+                arithm::addWeighted<unsigned short, unsigned short, int   >,
+                arithm::addWeighted<unsigned short, unsigned short, float >,
+                arithm::addWeighted<unsigned short, unsigned short, double>
             },
             {
-                addWeighted_gpu<unsigned short, short, unsigned char >,
-                addWeighted_gpu<unsigned short, short, signed char >,
-                addWeighted_gpu<unsigned short, short, unsigned short>,
-                addWeighted_gpu<unsigned short, short, short >,
-                addWeighted_gpu<unsigned short, short, int   >,
-                addWeighted_gpu<unsigned short, short, float >,
-                addWeighted_gpu<unsigned short, short, double>
+                arithm::addWeighted<unsigned short, short, unsigned char >,
+                arithm::addWeighted<unsigned short, short, signed char >,
+                arithm::addWeighted<unsigned short, short, unsigned short>,
+                arithm::addWeighted<unsigned short, short, short >,
+                arithm::addWeighted<unsigned short, short, int   >,
+                arithm::addWeighted<unsigned short, short, float >,
+                arithm::addWeighted<unsigned short, short, double>
             },
             {
-                addWeighted_gpu<unsigned short, int, unsigned char >,
-                addWeighted_gpu<unsigned short, int, signed char >,
-                addWeighted_gpu<unsigned short, int, unsigned short>,
-                addWeighted_gpu<unsigned short, int, short >,
-                addWeighted_gpu<unsigned short, int, int   >,
-                addWeighted_gpu<unsigned short, int, float >,
-                addWeighted_gpu<unsigned short, int, double>
+                arithm::addWeighted<unsigned short, int, unsigned char >,
+                arithm::addWeighted<unsigned short, int, signed char >,
+                arithm::addWeighted<unsigned short, int, unsigned short>,
+                arithm::addWeighted<unsigned short, int, short >,
+                arithm::addWeighted<unsigned short, int, int   >,
+                arithm::addWeighted<unsigned short, int, float >,
+                arithm::addWeighted<unsigned short, int, double>
             },
             {
-                addWeighted_gpu<unsigned short, float, unsigned char >,
-                addWeighted_gpu<unsigned short, float, signed char >,
-                addWeighted_gpu<unsigned short, float, unsigned short>,
-                addWeighted_gpu<unsigned short, float, short >,
-                addWeighted_gpu<unsigned short, float, int   >,
-                addWeighted_gpu<unsigned short, float, float >,
-                addWeighted_gpu<unsigned short, float, double>
+                arithm::addWeighted<unsigned short, float, unsigned char >,
+                arithm::addWeighted<unsigned short, float, signed char >,
+                arithm::addWeighted<unsigned short, float, unsigned short>,
+                arithm::addWeighted<unsigned short, float, short >,
+                arithm::addWeighted<unsigned short, float, int   >,
+                arithm::addWeighted<unsigned short, float, float >,
+                arithm::addWeighted<unsigned short, float, double>
             },
             {
-                addWeighted_gpu<unsigned short, double, unsigned char >,
-                addWeighted_gpu<unsigned short, double, signed char >,
-                addWeighted_gpu<unsigned short, double, unsigned short>,
-                addWeighted_gpu<unsigned short, double, short >,
-                addWeighted_gpu<unsigned short, double, int   >,
-                addWeighted_gpu<unsigned short, double, float >,
-                addWeighted_gpu<unsigned short, double, double>
+                arithm::addWeighted<unsigned short, double, unsigned char >,
+                arithm::addWeighted<unsigned short, double, signed char >,
+                arithm::addWeighted<unsigned short, double, unsigned short>,
+                arithm::addWeighted<unsigned short, double, short >,
+                arithm::addWeighted<unsigned short, double, int   >,
+                arithm::addWeighted<unsigned short, double, float >,
+                arithm::addWeighted<unsigned short, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<short, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<short, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<short, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<short, unsigned char, short >*/,
-                0/*addWeighted_gpu<short, unsigned char, int   >*/,
-                0/*addWeighted_gpu<short, unsigned char, float >*/,
-                0/*addWeighted_gpu<short, unsigned char, double>*/
+                0/*arithm::addWeighted<short, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<short, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<short, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<short, unsigned char, short >*/,
+                0/*arithm::addWeighted<short, unsigned char, int   >*/,
+                0/*arithm::addWeighted<short, unsigned char, float >*/,
+                0/*arithm::addWeighted<short, unsigned char, double>*/
             },
             {
-                0/*addWeighted_gpu<short, signed char, unsigned char >*/,
-                0/*addWeighted_gpu<short, signed char, signed char >*/,
-                0/*addWeighted_gpu<short, signed char, unsigned short>*/,
-                0/*addWeighted_gpu<short, signed char, short >*/,
-                0/*addWeighted_gpu<short, signed char, int   >*/,
-                0/*addWeighted_gpu<short, signed char, float >*/,
-                0/*addWeighted_gpu<short, signed char, double>*/
+                0/*arithm::addWeighted<short, signed char, unsigned char >*/,
+                0/*arithm::addWeighted<short, signed char, signed char >*/,
+                0/*arithm::addWeighted<short, signed char, unsigned short>*/,
+                0/*arithm::addWeighted<short, signed char, short >*/,
+                0/*arithm::addWeighted<short, signed char, int   >*/,
+                0/*arithm::addWeighted<short, signed char, float >*/,
+                0/*arithm::addWeighted<short, signed char, double>*/
             },
             {
-                0/*addWeighted_gpu<short, unsigned short, unsigned char >*/,
-                0/*addWeighted_gpu<short, unsigned short, signed char >*/,
-                0/*addWeighted_gpu<short, unsigned short, unsigned short>*/,
-                0/*addWeighted_gpu<short, unsigned short, short >*/,
-                0/*addWeighted_gpu<short, unsigned short, int   >*/,
-                0/*addWeighted_gpu<short, unsigned short, float >*/,
-                0/*addWeighted_gpu<short, unsigned short, double>*/
+                0/*arithm::addWeighted<short, unsigned short, unsigned char >*/,
+                0/*arithm::addWeighted<short, unsigned short, signed char >*/,
+                0/*arithm::addWeighted<short, unsigned short, unsigned short>*/,
+                0/*arithm::addWeighted<short, unsigned short, short >*/,
+                0/*arithm::addWeighted<short, unsigned short, int   >*/,
+                0/*arithm::addWeighted<short, unsigned short, float >*/,
+                0/*arithm::addWeighted<short, unsigned short, double>*/
             },
             {
-                addWeighted_gpu<short, short, unsigned char >,
-                addWeighted_gpu<short, short, signed char >,
-                addWeighted_gpu<short, short, unsigned short>,
-                addWeighted_gpu<short, short, short >,
-                addWeighted_gpu<short, short, int   >,
-                addWeighted_gpu<short, short, float >,
-                addWeighted_gpu<short, short, double>
+                arithm::addWeighted<short, short, unsigned char >,
+                arithm::addWeighted<short, short, signed char >,
+                arithm::addWeighted<short, short, unsigned short>,
+                arithm::addWeighted<short, short, short >,
+                arithm::addWeighted<short, short, int   >,
+                arithm::addWeighted<short, short, float >,
+                arithm::addWeighted<short, short, double>
             },
             {
-                addWeighted_gpu<short, int, unsigned char >,
-                addWeighted_gpu<short, int, signed char >,
-                addWeighted_gpu<short, int, unsigned short>,
-                addWeighted_gpu<short, int, short >,
-                addWeighted_gpu<short, int, int   >,
-                addWeighted_gpu<short, int, float >,
-                addWeighted_gpu<short, int, double>
+                arithm::addWeighted<short, int, unsigned char >,
+                arithm::addWeighted<short, int, signed char >,
+                arithm::addWeighted<short, int, unsigned short>,
+                arithm::addWeighted<short, int, short >,
+                arithm::addWeighted<short, int, int   >,
+                arithm::addWeighted<short, int, float >,
+                arithm::addWeighted<short, int, double>
             },
             {
-                addWeighted_gpu<short, float, unsigned char >,
-                addWeighted_gpu<short, float, signed char >,
-                addWeighted_gpu<short, float, unsigned short>,
-                addWeighted_gpu<short, float, short >,
-                addWeighted_gpu<short, float, int   >,
-                addWeighted_gpu<short, float, float >,
-                addWeighted_gpu<short, float, double>
+                arithm::addWeighted<short, float, unsigned char >,
+                arithm::addWeighted<short, float, signed char >,
+                arithm::addWeighted<short, float, unsigned short>,
+                arithm::addWeighted<short, float, short >,
+                arithm::addWeighted<short, float, int   >,
+                arithm::addWeighted<short, float, float >,
+                arithm::addWeighted<short, float, double>
             },
             {
-                addWeighted_gpu<short, double, unsigned char >,
-                addWeighted_gpu<short, double, signed char >,
-                addWeighted_gpu<short, double, unsigned short>,
-                addWeighted_gpu<short, double, short >,
-                addWeighted_gpu<short, double, int   >,
-                addWeighted_gpu<short, double, float >,
-                addWeighted_gpu<short, double, double>
+                arithm::addWeighted<short, double, unsigned char >,
+                arithm::addWeighted<short, double, signed char >,
+                arithm::addWeighted<short, double, unsigned short>,
+                arithm::addWeighted<short, double, short >,
+                arithm::addWeighted<short, double, int   >,
+                arithm::addWeighted<short, double, float >,
+                arithm::addWeighted<short, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<int, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<int, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<int, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<int, unsigned char, short >*/,
-                0/*addWeighted_gpu<int, unsigned char, int   >*/,
-                0/*addWeighted_gpu<int, unsigned char, float >*/,
-                0/*addWeighted_gpu<int, unsigned char, double>*/
+                0/*arithm::addWeighted<int, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<int, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<int, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<int, unsigned char, short >*/,
+                0/*arithm::addWeighted<int, unsigned char, int   >*/,
+                0/*arithm::addWeighted<int, unsigned char, float >*/,
+                0/*arithm::addWeighted<int, unsigned char, double>*/
             },
             {
-                0/*addWeighted_gpu<int, signed char, unsigned char >*/,
-                0/*addWeighted_gpu<int, signed char, signed char >*/,
-                0/*addWeighted_gpu<int, signed char, unsigned short>*/,
-                0/*addWeighted_gpu<int, signed char, short >*/,
-                0/*addWeighted_gpu<int, signed char, int   >*/,
-                0/*addWeighted_gpu<int, signed char, float >*/,
-                0/*addWeighted_gpu<int, signed char, double>*/
+                0/*arithm::addWeighted<int, signed char, unsigned char >*/,
+                0/*arithm::addWeighted<int, signed char, signed char >*/,
+                0/*arithm::addWeighted<int, signed char, unsigned short>*/,
+                0/*arithm::addWeighted<int, signed char, short >*/,
+                0/*arithm::addWeighted<int, signed char, int   >*/,
+                0/*arithm::addWeighted<int, signed char, float >*/,
+                0/*arithm::addWeighted<int, signed char, double>*/
             },
             {
-                0/*addWeighted_gpu<int, unsigned short, unsigned char >*/,
-                0/*addWeighted_gpu<int, unsigned short, signed char >*/,
-                0/*addWeighted_gpu<int, unsigned short, unsigned short>*/,
-                0/*addWeighted_gpu<int, unsigned short, short >*/,
-                0/*addWeighted_gpu<int, unsigned short, int   >*/,
-                0/*addWeighted_gpu<int, unsigned short, float >*/,
-                0/*addWeighted_gpu<int, unsigned short, double>*/
+                0/*arithm::addWeighted<int, unsigned short, unsigned char >*/,
+                0/*arithm::addWeighted<int, unsigned short, signed char >*/,
+                0/*arithm::addWeighted<int, unsigned short, unsigned short>*/,
+                0/*arithm::addWeighted<int, unsigned short, short >*/,
+                0/*arithm::addWeighted<int, unsigned short, int   >*/,
+                0/*arithm::addWeighted<int, unsigned short, float >*/,
+                0/*arithm::addWeighted<int, unsigned short, double>*/
             },
             {
-                0/*addWeighted_gpu<int, short, unsigned char >*/,
-                0/*addWeighted_gpu<int, short, signed char >*/,
-                0/*addWeighted_gpu<int, short, unsigned short>*/,
-                0/*addWeighted_gpu<int, short, short >*/,
-                0/*addWeighted_gpu<int, short, int   >*/,
-                0/*addWeighted_gpu<int, short, float >*/,
-                0/*addWeighted_gpu<int, short, double>*/
+                0/*arithm::addWeighted<int, short, unsigned char >*/,
+                0/*arithm::addWeighted<int, short, signed char >*/,
+                0/*arithm::addWeighted<int, short, unsigned short>*/,
+                0/*arithm::addWeighted<int, short, short >*/,
+                0/*arithm::addWeighted<int, short, int   >*/,
+                0/*arithm::addWeighted<int, short, float >*/,
+                0/*arithm::addWeighted<int, short, double>*/
             },
             {
-                addWeighted_gpu<int, int, unsigned char >,
-                addWeighted_gpu<int, int, signed char >,
-                addWeighted_gpu<int, int, unsigned short>,
-                addWeighted_gpu<int, int, short >,
-                addWeighted_gpu<int, int, int   >,
-                addWeighted_gpu<int, int, float >,
-                addWeighted_gpu<int, int, double>
+                arithm::addWeighted<int, int, unsigned char >,
+                arithm::addWeighted<int, int, signed char >,
+                arithm::addWeighted<int, int, unsigned short>,
+                arithm::addWeighted<int, int, short >,
+                arithm::addWeighted<int, int, int   >,
+                arithm::addWeighted<int, int, float >,
+                arithm::addWeighted<int, int, double>
             },
             {
-                addWeighted_gpu<int, float, unsigned char >,
-                addWeighted_gpu<int, float, signed char >,
-                addWeighted_gpu<int, float, unsigned short>,
-                addWeighted_gpu<int, float, short >,
-                addWeighted_gpu<int, float, int   >,
-                addWeighted_gpu<int, float, float >,
-                addWeighted_gpu<int, float, double>
+                arithm::addWeighted<int, float, unsigned char >,
+                arithm::addWeighted<int, float, signed char >,
+                arithm::addWeighted<int, float, unsigned short>,
+                arithm::addWeighted<int, float, short >,
+                arithm::addWeighted<int, float, int   >,
+                arithm::addWeighted<int, float, float >,
+                arithm::addWeighted<int, float, double>
             },
             {
-                addWeighted_gpu<int, double, unsigned char >,
-                addWeighted_gpu<int, double, signed char >,
-                addWeighted_gpu<int, double, unsigned short>,
-                addWeighted_gpu<int, double, short >,
-                addWeighted_gpu<int, double, int   >,
-                addWeighted_gpu<int, double, float >,
-                addWeighted_gpu<int, double, double>
+                arithm::addWeighted<int, double, unsigned char >,
+                arithm::addWeighted<int, double, signed char >,
+                arithm::addWeighted<int, double, unsigned short>,
+                arithm::addWeighted<int, double, short >,
+                arithm::addWeighted<int, double, int   >,
+                arithm::addWeighted<int, double, float >,
+                arithm::addWeighted<int, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<float, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<float, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<float, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<float, unsigned char, short >*/,
-                0/*addWeighted_gpu<float, unsigned char, int   >*/,
-                0/*addWeighted_gpu<float, unsigned char, float >*/,
-                0/*addWeighted_gpu<float, unsigned char, double>*/
+                0/*arithm::addWeighted<float, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<float, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<float, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<float, unsigned char, short >*/,
+                0/*arithm::addWeighted<float, unsigned char, int   >*/,
+                0/*arithm::addWeighted<float, unsigned char, float >*/,
+                0/*arithm::addWeighted<float, unsigned char, double>*/
             },
             {
-                0/*addWeighted_gpu<float, signed char, unsigned char >*/,
-                0/*addWeighted_gpu<float, signed char, signed char >*/,
-                0/*addWeighted_gpu<float, signed char, unsigned short>*/,
-                0/*addWeighted_gpu<float, signed char, short >*/,
-                0/*addWeighted_gpu<float, signed char, int   >*/,
-                0/*addWeighted_gpu<float, signed char, float >*/,
-                0/*addWeighted_gpu<float, signed char, double>*/
+                0/*arithm::addWeighted<float, signed char, unsigned char >*/,
+                0/*arithm::addWeighted<float, signed char, signed char >*/,
+                0/*arithm::addWeighted<float, signed char, unsigned short>*/,
+                0/*arithm::addWeighted<float, signed char, short >*/,
+                0/*arithm::addWeighted<float, signed char, int   >*/,
+                0/*arithm::addWeighted<float, signed char, float >*/,
+                0/*arithm::addWeighted<float, signed char, double>*/
             },
             {
-                0/*addWeighted_gpu<float, unsigned short, unsigned char >*/,
-                0/*addWeighted_gpu<float, unsigned short, signed char >*/,
-                0/*addWeighted_gpu<float, unsigned short, unsigned short>*/,
-                0/*addWeighted_gpu<float, unsigned short, short >*/,
-                0/*addWeighted_gpu<float, unsigned short, int   >*/,
-                0/*addWeighted_gpu<float, unsigned short, float >*/,
-                0/*addWeighted_gpu<float, unsigned short, double>*/
+                0/*arithm::addWeighted<float, unsigned short, unsigned char >*/,
+                0/*arithm::addWeighted<float, unsigned short, signed char >*/,
+                0/*arithm::addWeighted<float, unsigned short, unsigned short>*/,
+                0/*arithm::addWeighted<float, unsigned short, short >*/,
+                0/*arithm::addWeighted<float, unsigned short, int   >*/,
+                0/*arithm::addWeighted<float, unsigned short, float >*/,
+                0/*arithm::addWeighted<float, unsigned short, double>*/
             },
             {
-                0/*addWeighted_gpu<float, short, unsigned char >*/,
-                0/*addWeighted_gpu<float, short, signed char >*/,
-                0/*addWeighted_gpu<float, short, unsigned short>*/,
-                0/*addWeighted_gpu<float, short, short >*/,
-                0/*addWeighted_gpu<float, short, int   >*/,
-                0/*addWeighted_gpu<float, short, float >*/,
-                0/*addWeighted_gpu<float, short, double>*/
+                0/*arithm::addWeighted<float, short, unsigned char >*/,
+                0/*arithm::addWeighted<float, short, signed char >*/,
+                0/*arithm::addWeighted<float, short, unsigned short>*/,
+                0/*arithm::addWeighted<float, short, short >*/,
+                0/*arithm::addWeighted<float, short, int   >*/,
+                0/*arithm::addWeighted<float, short, float >*/,
+                0/*arithm::addWeighted<float, short, double>*/
             },
             {
-                0/*addWeighted_gpu<float, int, unsigned char >*/,
-                0/*addWeighted_gpu<float, int, signed char >*/,
-                0/*addWeighted_gpu<float, int, unsigned short>*/,
-                0/*addWeighted_gpu<float, int, short >*/,
-                0/*addWeighted_gpu<float, int, int   >*/,
-                0/*addWeighted_gpu<float, int, float >*/,
-                0/*addWeighted_gpu<float, int, double>*/
+                0/*arithm::addWeighted<float, int, unsigned char >*/,
+                0/*arithm::addWeighted<float, int, signed char >*/,
+                0/*arithm::addWeighted<float, int, unsigned short>*/,
+                0/*arithm::addWeighted<float, int, short >*/,
+                0/*arithm::addWeighted<float, int, int   >*/,
+                0/*arithm::addWeighted<float, int, float >*/,
+                0/*arithm::addWeighted<float, int, double>*/
             },
             {
-                addWeighted_gpu<float, float, unsigned char >,
-                addWeighted_gpu<float, float, signed char >,
-                addWeighted_gpu<float, float, unsigned short>,
-                addWeighted_gpu<float, float, short >,
-                addWeighted_gpu<float, float, int   >,
-                addWeighted_gpu<float, float, float >,
-                addWeighted_gpu<float, float, double>
+                arithm::addWeighted<float, float, unsigned char >,
+                arithm::addWeighted<float, float, signed char >,
+                arithm::addWeighted<float, float, unsigned short>,
+                arithm::addWeighted<float, float, short >,
+                arithm::addWeighted<float, float, int   >,
+                arithm::addWeighted<float, float, float >,
+                arithm::addWeighted<float, float, double>
             },
             {
-                addWeighted_gpu<float, double, unsigned char >,
-                addWeighted_gpu<float, double, signed char >,
-                addWeighted_gpu<float, double, unsigned short>,
-                addWeighted_gpu<float, double, short >,
-                addWeighted_gpu<float, double, int   >,
-                addWeighted_gpu<float, double, float >,
-                addWeighted_gpu<float, double, double>
+                arithm::addWeighted<float, double, unsigned char >,
+                arithm::addWeighted<float, double, signed char >,
+                arithm::addWeighted<float, double, unsigned short>,
+                arithm::addWeighted<float, double, short >,
+                arithm::addWeighted<float, double, int   >,
+                arithm::addWeighted<float, double, float >,
+                arithm::addWeighted<float, double, double>
             }
         },
         {
             {
-                0/*addWeighted_gpu<double, unsigned char, unsigned char >*/,
-                0/*addWeighted_gpu<double, unsigned char, signed char >*/,
-                0/*addWeighted_gpu<double, unsigned char, unsigned short>*/,
-                0/*addWeighted_gpu<double, unsigned char, short >*/,
-                0/*addWeighted_gpu<double, unsigned char, int   >*/,
-                0/*addWeighted_gpu<double, unsigned char, float >*/,
-                0/*addWeighted_gpu<double, unsigned char, double>*/
+                0/*arithm::addWeighted<double, unsigned char, unsigned char >*/,
+                0/*arithm::addWeighted<double, unsigned char, signed char >*/,
+                0/*arithm::addWeighted<double, unsigned char, unsigned short>*/,
+                0/*arithm::addWeighted<double, unsigned char, short >*/,
+                0/*arithm::addWeighted<double, unsigned char, int   >*/,
+                0/*arithm::addWeighted<double, unsigned char, float >*/,
+                0/*arithm::addWeighted<double, unsigned char, double>*/
             },
             {
-                0/*addWeighted_gpu<double, signed char, unsigned char >*/,
-                0/*addWeighted_gpu<double, signed char, signed char >*/,
-                0/*addWeighted_gpu<double, signed char, unsigned short>*/,
-                0/*addWeighted_gpu<double, signed char, short >*/,
-                0/*addWeighted_gpu<double, signed char, int   >*/,
-                0/*addWeighted_gpu<double, signed char, float >*/,
-                0/*addWeighted_gpu<double, signed char, double>*/
+                0/*arithm::addWeighted<double, signed char, unsigned char >*/,
+                0/*arithm::addWeighted<double, signed char, signed char >*/,
+                0/*arithm::addWeighted<double, signed char, unsigned short>*/,
+                0/*arithm::addWeighted<double, signed char, short >*/,
+                0/*arithm::addWeighted<double, signed char, int   >*/,
+                0/*arithm::addWeighted<double, signed char, float >*/,
+                0/*arithm::addWeighted<double, signed char, double>*/
             },
             {
-                0/*addWeighted_gpu<double, unsigned short, unsigned char >*/,
-                0/*addWeighted_gpu<double, unsigned short, signed char >*/,
-                0/*addWeighted_gpu<double, unsigned short, unsigned short>*/,
-                0/*addWeighted_gpu<double, unsigned short, short >*/,
-                0/*addWeighted_gpu<double, unsigned short, int   >*/,
-                0/*addWeighted_gpu<double, unsigned short, float >*/,
-                0/*addWeighted_gpu<double, unsigned short, double>*/
+                0/*arithm::addWeighted<double, unsigned short, unsigned char >*/,
+                0/*arithm::addWeighted<double, unsigned short, signed char >*/,
+                0/*arithm::addWeighted<double, unsigned short, unsigned short>*/,
+                0/*arithm::addWeighted<double, unsigned short, short >*/,
+                0/*arithm::addWeighted<double, unsigned short, int   >*/,
+                0/*arithm::addWeighted<double, unsigned short, float >*/,
+                0/*arithm::addWeighted<double, unsigned short, double>*/
             },
             {
-                0/*addWeighted_gpu<double, short, unsigned char >*/,
-                0/*addWeighted_gpu<double, short, signed char >*/,
-                0/*addWeighted_gpu<double, short, unsigned short>*/,
-                0/*addWeighted_gpu<double, short, short >*/,
-                0/*addWeighted_gpu<double, short, int   >*/,
-                0/*addWeighted_gpu<double, short, float >*/,
-                0/*addWeighted_gpu<double, short, double>*/
+                0/*arithm::addWeighted<double, short, unsigned char >*/,
+                0/*arithm::addWeighted<double, short, signed char >*/,
+                0/*arithm::addWeighted<double, short, unsigned short>*/,
+                0/*arithm::addWeighted<double, short, short >*/,
+                0/*arithm::addWeighted<double, short, int   >*/,
+                0/*arithm::addWeighted<double, short, float >*/,
+                0/*arithm::addWeighted<double, short, double>*/
             },
             {
-                0/*addWeighted_gpu<double, int, unsigned char >*/,
-                0/*addWeighted_gpu<double, int, signed char >*/,
-                0/*addWeighted_gpu<double, int, unsigned short>*/,
-                0/*addWeighted_gpu<double, int, short >*/,
-                0/*addWeighted_gpu<double, int, int   >*/,
-                0/*addWeighted_gpu<double, int, float >*/,
-                0/*addWeighted_gpu<double, int, double>*/
+                0/*arithm::addWeighted<double, int, unsigned char >*/,
+                0/*arithm::addWeighted<double, int, signed char >*/,
+                0/*arithm::addWeighted<double, int, unsigned short>*/,
+                0/*arithm::addWeighted<double, int, short >*/,
+                0/*arithm::addWeighted<double, int, int   >*/,
+                0/*arithm::addWeighted<double, int, float >*/,
+                0/*arithm::addWeighted<double, int, double>*/
             },
             {
-                0/*addWeighted_gpu<double, float, unsigned char >*/,
-                0/*addWeighted_gpu<double, float, signed char >*/,
-                0/*addWeighted_gpu<double, float, unsigned short>*/,
-                0/*addWeighted_gpu<double, float, short >*/,
-                0/*addWeighted_gpu<double, float, int   >*/,
-                0/*addWeighted_gpu<double, float, float >*/,
-                0/*addWeighted_gpu<double, float, double>*/
+                0/*arithm::addWeighted<double, float, unsigned char >*/,
+                0/*arithm::addWeighted<double, float, signed char >*/,
+                0/*arithm::addWeighted<double, float, unsigned short>*/,
+                0/*arithm::addWeighted<double, float, short >*/,
+                0/*arithm::addWeighted<double, float, int   >*/,
+                0/*arithm::addWeighted<double, float, float >*/,
+                0/*arithm::addWeighted<double, float, double>*/
             },
             {
-                addWeighted_gpu<double, double, unsigned char >,
-                addWeighted_gpu<double, double, signed char >,
-                addWeighted_gpu<double, double, unsigned short>,
-                addWeighted_gpu<double, double, short >,
-                addWeighted_gpu<double, double, int   >,
-                addWeighted_gpu<double, double, float >,
-                addWeighted_gpu<double, double, double>
+                arithm::addWeighted<double, double, unsigned char >,
+                arithm::addWeighted<double, double, signed char >,
+                arithm::addWeighted<double, double, unsigned short>,
+                arithm::addWeighted<double, double, short >,
+                arithm::addWeighted<double, double, int   >,
+                arithm::addWeighted<double, double, float >,
+                arithm::addWeighted<double, double, double>
             }
         }
     };
 
-    CV_Assert(src1.size() == src2.size());
-    CV_Assert(src1.type() == src2.type() || (dtype >= 0 && src1.channels() == src2.channels()));
+    int sdepth1 = src1.depth();
+    int sdepth2 = src2.depth();
+    ddepth = ddepth >= 0 ? CV_MAT_DEPTH(ddepth) : std::max(sdepth1, sdepth2);
+    const int cn = src1.channels();
 
-    dtype = dtype >= 0 ? CV_MAKETYPE(dtype, src1.channels()) : src1.type();
+    CV_Assert( src2.size() == src1.size() && src2.channels() == cn );
+    CV_Assert( sdepth1 <= CV_64F && sdepth2 <= CV_64F && ddepth <= CV_64F );
 
-    CV_Assert(src1.depth() <= CV_64F && src2.depth() <= CV_64F && CV_MAT_DEPTH(dtype) <= CV_64F);
-
-    if (src1.depth() == CV_64F || src2.depth() == CV_64F || CV_MAT_DEPTH(dtype) == CV_64F)
+    if (sdepth1 == CV_64F || sdepth2 == CV_64F || ddepth == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
-    dst.create(src1.size(), dtype);
+    dst.create(src1.size(), CV_MAKE_TYPE(ddepth, cn));
 
-    const GpuMat* psrc1 = &src1;
-    const GpuMat* psrc2 = &src2;
+    PtrStepSzb src1_(src1.rows, src1.cols * cn, src1.data, src1.step);
+    PtrStepSzb src2_(src1.rows, src1.cols * cn, src2.data, src2.step);
+    PtrStepSzb dst_(src1.rows, src1.cols * cn, dst.data, dst.step);
 
-    if (src1.depth() > src2.depth())
+    if (sdepth1 > sdepth2)
     {
-        std::swap(psrc1, psrc2);
+        std::swap(src1_.data, src2_.data);
+        std::swap(src1_.step, src2_.step);
         std::swap(alpha, beta);
+        std::swap(sdepth1, sdepth2);
     }
 
-    const func_t func = funcs[psrc1->depth()][psrc2->depth()][dst.depth()];
+    const func_t func = funcs[sdepth1][sdepth2][ddepth];
 
     if (!func)
         CV_Error(CV_StsUnsupportedFormat, "Unsupported combination of source and destination types");
 
-    func(psrc1->reshape(1), alpha, psrc2->reshape(1), beta, gamma, dst.reshape(1), StreamAccessor::getStream(stream));
+    func(src1_, alpha, src2_, beta, gamma, dst_, StreamAccessor::getStream(stream));
 }
 
 #endif
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index abdcb0fa7..695ec9758 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -210,7 +210,6 @@ TEST_P(Add_Array, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
     if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
@@ -228,10 +227,10 @@ TEST_P(Add_Array, Accuracy)
     {
         cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
         dst.setTo(cv::Scalar::all(0));
-        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, channels == 1 ? loadMat(mask, useRoi) : cv::gpu::GpuMat(), depth.second);
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
 
         cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::add(mat1, mat2, dst_gold, channels == 1 ? mask : cv::noArray(), depth.second);
+        cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
 
         EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
@@ -244,6 +243,67 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Add_Array, testing::Combine(
     ALL_CHANNELS,
     WHOLE_SUBMAT));
 
+PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    std::pair<MatDepth, MatDepth> depth;
+    bool useRoi;
+
+    int stype;
+    int dtype;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth = GET_PARAM(2);
+        useRoi = GET_PARAM(3);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        stype = CV_MAKE_TYPE(depth.first, 1);
+        dtype = CV_MAKE_TYPE(depth.second, 1);
+    }
+};
+
+TEST_P(Add_Array_Mask, Accuracy)
+{
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Core, Add_Array_Mask, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    DEPTH_PAIRS,
+    WHOLE_SUBMAT));
+
 ////////////////////////////////////////////////////////////////////////////////
 // Add_Scalar
 
@@ -362,6 +422,67 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 };
 
 TEST_P(Subtract_Array, Accuracy)
+{
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Core, Subtract_Array, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    DEPTH_PAIRS,
+    ALL_CHANNELS,
+    WHOLE_SUBMAT));
+
+PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, MatDepth>, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    cv::Size size;
+    std::pair<MatDepth, MatDepth> depth;
+    bool useRoi;
+
+    int stype;
+    int dtype;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        size = GET_PARAM(1);
+        depth = GET_PARAM(2);
+        useRoi = GET_PARAM(3);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        stype = CV_MAKE_TYPE(depth.first, 1);
+        dtype = CV_MAKE_TYPE(depth.second, 1);
+    }
+};
+
+TEST_P(Subtract_Array_Mask, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -383,20 +504,19 @@ TEST_P(Subtract_Array, Accuracy)
     {
         cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
         dst.setTo(cv::Scalar::all(0));
-        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, channels == 1 ? loadMat(mask, useRoi) : cv::gpu::GpuMat(), depth.second);
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
 
         cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::subtract(mat1, mat2, dst_gold, channels == 1 ? mask : cv::noArray(), depth.second);
+        cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
 
         EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
-INSTANTIATE_TEST_CASE_P(GPU_Core, Subtract_Array, testing::Combine(
+INSTANTIATE_TEST_CASE_P(GPU_Core, Subtract_Array_Mask, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
     DEPTH_PAIRS,
-    ALL_CHANNELS,
     WHOLE_SUBMAT));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -541,7 +661,7 @@ TEST_P(Multiply_Array, WithOutScale)
         cv::Mat dst_gold;
         cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 
@@ -571,7 +691,7 @@ TEST_P(Multiply_Array, WithScale)
         cv::Mat dst_gold;
         cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
     }
 }
 
@@ -726,7 +846,7 @@ TEST_P(Multiply_Scalar, WithOutScale)
         cv::Mat dst_gold;
         cv::multiply(mat, val, dst_gold, 1, depth.second);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
@@ -757,7 +877,7 @@ TEST_P(Multiply_Scalar, WithScale)
         cv::Mat dst_gold;
         cv::multiply(mat, val, dst_gold, scale, depth.second);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
@@ -1037,7 +1157,7 @@ TEST_P(Divide_Scalar, WithScale)
         cv::Mat dst_gold;
         cv::divide(mat, val, dst_gold, scale, depth.second);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 

From 63a022dcd74e4d9058c12693dbe2e2f47dd8481f Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 26 Nov 2012 13:12:50 +0400
Subject: [PATCH 096/155] added explicit unroll to reduce implementation

---
 .../opencv2/gpu/device/detail/reduce.hpp      | 65 ++++++++++---------
 .../gpu/device/detail/reduce_key_val.hpp      | 65 ++++++++++---------
 2 files changed, 68 insertions(+), 62 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
index 2b2ba6773..091a160e3 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce.hpp
@@ -243,29 +243,46 @@ namespace cv { namespace gpu { namespace device
             }
         };
 
+        template <unsigned int I, typename Pointer, typename Reference, class Op>
+        struct Unroll
+        {
+            static __device__ void loopShfl(Reference val, Op op, unsigned int N)
+            {
+                mergeShfl(val, I, N, op);
+                Unroll<I / 2, Pointer, Reference, Op>::loopShfl(val, op, N);
+            }
+            static __device__ void loop(Pointer smem, Reference val, unsigned int tid, Op op)
+            {
+                merge(smem, val, tid, I, op);
+                Unroll<I / 2, Pointer, Reference, Op>::loop(smem, val, tid, op);
+            }
+        };
+        template <typename Pointer, typename Reference, class Op>
+        struct Unroll<0, Pointer, Reference, Op>
+        {
+            static __device__ void loopShfl(Reference, Op, unsigned int)
+            {
+            }
+            static __device__ void loop(Pointer, Reference, unsigned int, Op)
+            {
+            }
+        };
+
         template <unsigned int N> struct WarpOptimized
         {
             template <typename Pointer, typename Reference, class Op>
             static __device__ void reduce(Pointer smem, Reference val, unsigned int tid, Op op)
             {
-            #if __CUDA_ARCH >= 300
+            #if __CUDA_ARCH__ >= 300
                 (void) smem;
                 (void) tid;
 
-                #pragma unroll
-                for (unsigned int i = N / 2; i >= 1; i /= 2)
-                    mergeShfl(val, i, N, op);
+                Unroll<N / 2, Pointer, Reference, Op>::loopShfl(val, op, N);
             #else
                 loadToSmem(smem, val, tid);
 
                 if (tid < N / 2)
-                {
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (unsigned int i = N / 2; i >= 1; i /= 2)
-                        merge(smem, val, tid, i, op);
-                }
+                    Unroll<N / 2, Pointer, Reference, Op>::loop(smem, val, tid, op);
             #endif
             }
         };
@@ -279,10 +296,8 @@ namespace cv { namespace gpu { namespace device
             {
                 const unsigned int laneId = Warp::laneId();
 
-            #if __CUDA_ARCH >= 300
-                #pragma unroll
-                for (int i = 16; i >= 1; i /= 2)
-                    mergeShfl(val, i, warpSize, op);
+            #if __CUDA_ARCH__ >= 300
+                Unroll<16, Pointer, Reference, Op>::loopShfl(val, op, warpSize);
 
                 if (laneId == 0)
                     loadToSmem(smem, val, tid / 32);
@@ -290,13 +305,7 @@ namespace cv { namespace gpu { namespace device
                 loadToSmem(smem, val, tid);
 
                 if (laneId < 16)
-                {
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (int i = 16; i >= 1; i /= 2)
-                        merge(smem, val, tid, i, op);
-                }
+                    Unroll<16, Pointer, Reference, Op>::loop(smem, val, tid, op);
 
                 __syncthreads();
 
@@ -310,16 +319,10 @@ namespace cv { namespace gpu { namespace device
 
                 if (tid < 32)
                 {
-                #if __CUDA_ARCH >= 300
-                    #pragma unroll
-                    for (int i = M / 2; i >= 1; i /= 2)
-                        mergeShfl(val, i, M, op);
+                #if __CUDA_ARCH__ >= 300
+                    Unroll<M / 2, Pointer, Reference, Op>::loopShfl(val, op, M);
                 #else
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (int i = M / 2; i >= 1; i /= 2)
-                        merge(smem, val, tid, i, op);
+                    Unroll<M / 2, Pointer, Reference, Op>::loop(smem, val, tid, op);
                 #endif
                 }
             }
diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
index f1aa285d3..ca2c43127 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
@@ -369,31 +369,48 @@ namespace cv { namespace gpu { namespace device
             }
         };
 
+        template <unsigned int I, class KP, class KR, class VP, class VR, class Cmp>
+        struct Unroll
+        {
+            static __device__ void loopShfl(KR key, VR val, Cmp cmp, unsigned int N)
+            {
+                mergeShfl(key, val, cmp, I, N);
+                Unroll<I / 2, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, N);
+            }
+            static __device__ void loop(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
+            {
+                merge(skeys, key, svals, val, cmp, tid, I);
+                Unroll<I / 2, KP, KR, VP, VR, Cmp>::loop(skeys, key, svals, val, tid, cmp);
+            }
+        };
+        template <class KP, class KR, class VP, class VR, class Cmp>
+        struct Unroll<0, KP, KR, VP, VR, Cmp>
+        {
+            static __device__ void loopShfl(KR, VR, Cmp, unsigned int)
+            {
+            }
+            static __device__ void loop(KP, KR, VP, VR, unsigned int, Cmp)
+            {
+            }
+        };
+
         template <unsigned int N> struct WarpOptimized
         {
             template <class KP, class KR, class VP, class VR, class Cmp>
             static __device__ void reduce(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
             {
-            #if __CUDA_ARCH >= 300
+            #if __CUDA_ARCH__ >= 300
                 (void) skeys;
                 (void) svals;
                 (void) tid;
 
-                #pragma unroll
-                for (unsigned int i = N / 2; i >= 1; i /= 2)
-                    mergeShfl(key, val, cml, i, N);
+                Unroll<N / 2, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, N);
             #else
                 loadToSmem(skeys, key, tid);
                 loadToSmem(svals, val, tid);
 
                 if (tid < N / 2)
-                {
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (unsigned int i = N / 2; i >= 1; i /= 2)
-                        merge(skeys, key, svals, val, cmp, tid, i);
-                }
+                    Unroll<N / 2, KP, KR, VP, VR, Cmp>::loop(skeys, key, svals, val, tid, cmp);
             #endif
             }
         };
@@ -407,10 +424,8 @@ namespace cv { namespace gpu { namespace device
             {
                 const unsigned int laneId = Warp::laneId();
 
-            #if __CUDA_ARCH >= 300
-                #pragma unroll
-                for (unsigned int i = 16; i >= 1; i /= 2)
-                    mergeShfl(key, val, cml, i, warpSize);
+            #if __CUDA_ARCH__ >= 300
+                Unroll<16, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, warpSize);
 
                 if (laneId == 0)
                 {
@@ -422,13 +437,7 @@ namespace cv { namespace gpu { namespace device
                 loadToSmem(svals, val, tid);
 
                 if (laneId < 16)
-                {
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (int i = 16; i >= 1; i /= 2)
-                        merge(skeys, key, svals, val, cmp, tid, i);
-                }
+                    Unroll<16, KP, KR, VP, VR, Cmp>::loop(skeys, key, svals, val, tid, cmp);
 
                 __syncthreads();
 
@@ -445,18 +454,12 @@ namespace cv { namespace gpu { namespace device
 
                 if (tid < 32)
                 {
-                #if __CUDA_ARCH >= 300
+                #if __CUDA_ARCH__ >= 300
                     loadFromSmem(svals, val, tid);
 
-                    #pragma unroll
-                    for (unsigned int i = M / 2; i >= 1; i /= 2)
-                        mergeShfl(key, val, cml, i, M);
+                    Unroll<M / 2, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, M);
                 #else
-                #if __CUDA_ARCH__ >= 200
-                    #pragma unroll
-                #endif
-                    for (unsigned int i = M / 2; i >= 1; i /= 2)
-                        merge(skeys, key, svals, val, cmp, tid, i);
+                    Unroll<M / 2, KP, KR, VP, VR, Cmp>::loop(skeys, key, svals, val, tid, cmp);
                 #endif
                 }
             }

From d2e88e1d4d0e7cf803187e97588a0a4a4338444f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 26 Nov 2012 15:26:11 +0400
Subject: [PATCH 097/155] nms: part 1

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  6 ++-
 modules/gpu/src/cuda/icf-sc.cu          | 67 ++++++++++++++++++++++++-
 modules/gpu/src/gpu_init.cpp            |  8 +--
 modules/gpu/src/softcascade.cpp         | 22 +++++++-
 4 files changed, 95 insertions(+), 8 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index db228a69b..8362282b0 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1552,12 +1552,14 @@ public:
         enum {PEDESTRIAN = 0};
     };
 
+    enum { NO_REJECT = 1, DOLLAR = 2, /*PASCAL = 4,*/ DEFAULT = NO_REJECT};
+
     // An empty cascade will be created.
     // Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
     // Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
     // Param scales is a number of scales from minScale to maxScale.
     // Param rejfactor is used for NMS.
-    SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55, const int rejfactor = 1);
+    SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55, const int rejCriteria = 1);
 
     virtual ~SCascade();
 
@@ -1595,7 +1597,7 @@ private:
     double maxScale;
 
     int scales;
-    int rejfactor;
+    int rejCriteria;
 };
 
 ////////////////////////////////// SURF //////////////////////////////////////////
diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 27d60e637..5334441d8 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -41,9 +41,10 @@
 //M*/
 
 #include <opencv2/gpu/device/common.hpp>
+
 #include <icf.hpp>
-#include <stdio.h>
 #include <float.h>
+#include <stdio.h>
 
 namespace cv { namespace gpu { namespace device {
 namespace icf {
@@ -79,6 +80,70 @@ namespace icf {
         }
     }
 
+    __device__ __forceinline__ float overlapArea(const Detection &a, const Detection &b)
+    {
+        int w = ::min(a.x + a.w, b.x + b.w) - ::max(a.x, b.x);
+        int h = ::min(a.y + a.h, b.y + b.h) - ::max(a.y, b.y);
+
+        return (w < 0 || h < 0)? 0.f : (float)(w * h);
+    }
+
+    __global__ void overlap(const uint* n, const Detection* detections, uchar* overlaps)
+    {
+        const int idx = threadIdx.x;
+        const int total = *n;
+
+        for (int i = idx; i < total; i += 192)
+        {
+            const Detection& a = detections[i];
+            bool excluded = false;
+
+            for (int j = i + 1; j < total; ++j)
+            {
+                const Detection& b = detections[j];
+                float ovl = overlapArea(a, b) / ::min(a.w * a.h, b.w * b.h);
+
+                if (ovl > 0.65f)
+                {
+                    int suppessed = (a.confidence > b.confidence)? j : i;
+                    overlaps[suppessed] = 1;
+                    excluded = excluded || (suppessed == i);
+                }
+
+                if (__all(excluded)) break;
+            }
+        }
+    }
+
+    __global__ void collect(const uint* n, const Detection* detections, uchar* overlaps)
+    {
+        const int idx = threadIdx.x;
+        const int total = *n;
+
+        for (int i = idx; i < total; i += 192)
+        {
+            if (!overlaps[i])
+            {
+                const Detection& det = detections[i];
+                // printf("%d: %d %d %d %d %f\n", i, det.x, det.y, det.w, det.h, det.confidence );
+            }
+        }
+    }
+
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections)
+    {
+        int block = 192;
+        int grid = 1;
+
+        overlap<<<grid, block>>>((uint*)ndetections.ptr(0), (Detection*)objects.ptr(0), (uchar*)overlaps.ptr(0));
+        collect<<<grid, block>>>((uint*)ndetections.ptr(0), (Detection*)objects.ptr(0), (uchar*)overlaps.ptr(0));
+        // if (!stream)
+        {
+            cudaSafeCall( cudaGetLastError());
+            cudaSafeCall( cudaDeviceSynchronize());
+        }
+    }
+
     template<typename Policy>
     struct PrefixSum
     {
diff --git a/modules/gpu/src/gpu_init.cpp b/modules/gpu/src/gpu_init.cpp
index f25bc2ceb..773a8b64e 100644
--- a/modules/gpu/src/gpu_init.cpp
+++ b/modules/gpu/src/gpu_init.cpp
@@ -46,10 +46,10 @@ namespace cv { namespace gpu
 {
 
 CV_INIT_ALGORITHM(SCascade, "CascadeDetector.SCascade",
-                  obj.info()->addParam(obj, "minScale",  obj.minScale);
-                  obj.info()->addParam(obj, "maxScale",  obj.maxScale);
-                  obj.info()->addParam(obj, "scales",    obj.scales);
-                  obj.info()->addParam(obj, "rejfactor", obj.rejfactor));
+                  obj.info()->addParam(obj, "minScale",    obj.minScale);
+                  obj.info()->addParam(obj, "maxScale",    obj.maxScale);
+                  obj.info()->addParam(obj, "scales",      obj.scales);
+                  obj.info()->addParam(obj, "rejCriteria", obj.rejCriteria));
 
 bool initModule_gpu(void)
 {
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index d5a8e8481..35bd72e55 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -85,6 +85,8 @@ namespace cv { namespace gpu { namespace device {
 namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins, cudaStream_t stream);
+
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections);
 }
 
 namespace imgproc {
@@ -309,6 +311,8 @@ struct cv::gpu::SCascade::Fields
         hogluv.create((fh / shr) * HOG_LUV_BINS + 1, fw / shr + 1, CV_32SC1);
         hogluv.setTo(cv::Scalar::all(0));
 
+        overlaps.create(1, 5000, CV_8UC1);
+
         return true;
     }
 
@@ -437,7 +441,15 @@ private:
         }
     }
 
+#include <iostream>
 public:
+    void suppress(GpuMat& ndetections, GpuMat& objects)
+    {
+        ensureSizeIsEnough(objects.rows, objects.cols, CV_8UC1, overlaps);
+        overlaps.setTo(0);
+        device::icf::suppress(objects, overlaps, ndetections);
+        // std::cout << cv::Mat(overlaps) << std::endl;
+    }
 
     // scales range
     float minScale;
@@ -469,6 +481,9 @@ public:
     // 161x121x10
     GpuMat hogluv;
 
+    // used for area overlap computing during
+    GpuMat overlaps;
+
     // Cascade from xml
     GpuMat octaves;
     GpuMat stages;
@@ -478,6 +493,8 @@ public:
 
     GpuMat sobelBuf;
 
+    GpuMat collected;
+
     std::vector<device::icf::Octave> voctaves;
 
     DeviceInfo info;
@@ -494,7 +511,7 @@ public:
 };
 
 cv::gpu::SCascade::SCascade(const double mins, const double maxs, const int sc, const int rjf)
-: fields(0),  minScale(mins), maxScale(maxs), scales(sc), rejfactor(rjf) {}
+: fields(0),  minScale(mins), maxScale(maxs), scales(sc), rejCriteria(rjf) {}
 
 cv::gpu::SCascade::~SCascade() { delete fields; }
 
@@ -534,6 +551,9 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     cudaStream_t stream = StreamAccessor::getStream(s);
 
     flds.detect(rois, tmp, objects, stream);
+
+    // if (rejCriteria != NO_REJECT)
+    flds.suppress(tmp, objects);
 }
 
 void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const

From f022b12c579a9deca9b7c6abdf76dc282dd235b2 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 26 Nov 2012 15:36:15 +0400
Subject: [PATCH 098/155] saturate_cast via asm cvt command

---
 .../opencv2/gpu/device/saturate_cast.hpp      | 176 ++++++++++++------
 1 file changed, 122 insertions(+), 54 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/saturate_cast.hpp b/modules/gpu/include/opencv2/gpu/device/saturate_cast.hpp
index 7bb1da751..7a2799fa3 100644
--- a/modules/gpu/include/opencv2/gpu/device/saturate_cast.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/saturate_cast.hpp
@@ -58,35 +58,47 @@ namespace cv { namespace gpu { namespace device
 
     template<> __device__ __forceinline__ uchar saturate_cast<uchar>(schar v)
     {
-        return (uchar) ::max((int)v, 0);
-    }
-    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(ushort v)
-    {
-        return (uchar) ::min((uint)v, (uint)UCHAR_MAX);
-    }
-    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(int v)
-    {
-        return (uchar)((uint)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0);
-    }
-    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(uint v)
-    {
-        return (uchar) ::min(v, (uint)UCHAR_MAX);
+        uint res = 0;
+        int vi = v;
+        asm("cvt.sat.u8.s8 %0, %1;" : "=r"(res) : "r"(vi));
+        return res;
     }
     template<> __device__ __forceinline__ uchar saturate_cast<uchar>(short v)
     {
-        return saturate_cast<uchar>((uint)v);
+        uint res = 0;
+        asm("cvt.sat.u8.s16 %0, %1;" : "=r"(res) : "h"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(ushort v)
+    {
+        uint res = 0;
+        asm("cvt.sat.u8.u16 %0, %1;" : "=r"(res) : "h"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(int v)
+    {
+        uint res = 0;
+        asm("cvt.sat.u8.s32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ uchar saturate_cast<uchar>(uint v)
+    {
+        uint res = 0;
+        asm("cvt.sat.u8.u32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
     }
-
     template<> __device__ __forceinline__ uchar saturate_cast<uchar>(float v)
     {
-        int iv = __float2int_rn(v);
-        return saturate_cast<uchar>(iv);
+        uint res = 0;
+        asm("cvt.rni.sat.u8.f32 %0, %1;" : "=r"(res) : "f"(v));
+        return res;
     }
     template<> __device__ __forceinline__ uchar saturate_cast<uchar>(double v)
     {
-    #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 130
-        int iv = __double2int_rn(v);
-        return saturate_cast<uchar>(iv);
+    #if __CUDA_ARCH__ >= 130
+        uint res = 0;
+        asm("cvt.rni.sat.u8.f64 %0, %1;" : "=r"(res) : "d"(v));
+        return res;
     #else
         return saturate_cast<uchar>((float)v);
     #endif
@@ -94,35 +106,47 @@ namespace cv { namespace gpu { namespace device
 
     template<> __device__ __forceinline__ schar saturate_cast<schar>(uchar v)
     {
-        return (schar) ::min((int)v, SCHAR_MAX);
-    }
-    template<> __device__ __forceinline__ schar saturate_cast<schar>(ushort v)
-    {
-        return (schar) ::min((uint)v, (uint)SCHAR_MAX);
-    }
-    template<> __device__ __forceinline__ schar saturate_cast<schar>(int v)
-    {
-        return (schar)((uint)(v-SCHAR_MIN) <= (uint)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN);
+        uint res = 0;
+        uint vi = v;
+        asm("cvt.sat.s8.u8 %0, %1;" : "=r"(res) : "r"(vi));
+        return res;
     }
     template<> __device__ __forceinline__ schar saturate_cast<schar>(short v)
     {
-        return saturate_cast<schar>((int)v);
+        uint res = 0;
+        asm("cvt.sat.s8.s16 %0, %1;" : "=r"(res) : "h"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ schar saturate_cast<schar>(ushort v)
+    {
+        uint res = 0;
+        asm("cvt.sat.s8.u16 %0, %1;" : "=r"(res) : "h"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ schar saturate_cast<schar>(int v)
+    {
+        uint res = 0;
+        asm("cvt.sat.s8.s32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
     }
     template<> __device__ __forceinline__ schar saturate_cast<schar>(uint v)
     {
-        return (schar) ::min(v, (uint)SCHAR_MAX);
+        uint res = 0;
+        asm("cvt.sat.s8.u32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
     }
-
     template<> __device__ __forceinline__ schar saturate_cast<schar>(float v)
     {
-        int iv = __float2int_rn(v);
-        return saturate_cast<schar>(iv);
+        uint res = 0;
+        asm("cvt.rni.sat.s8.f32 %0, %1;" : "=r"(res) : "f"(v));
+        return res;
     }
     template<> __device__ __forceinline__ schar saturate_cast<schar>(double v)
     {
-    #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 130
-        int iv = __double2int_rn(v);
-        return saturate_cast<schar>(iv);
+    #if __CUDA_ARCH__ >= 130
+        uint res = 0;
+        asm("cvt.rni.sat.s8.f64 %0, %1;" : "=r"(res) : "d"(v));
+        return res;
     #else
         return saturate_cast<schar>((float)v);
     #endif
@@ -130,30 +154,41 @@ namespace cv { namespace gpu { namespace device
 
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(schar v)
     {
-        return (ushort) ::max((int)v, 0);
+        ushort res = 0;
+        int vi = v;
+        asm("cvt.sat.u16.s8 %0, %1;" : "=h"(res) : "r"(vi));
+        return res;
     }
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(short v)
     {
-        return (ushort) ::max((int)v, 0);
+        ushort res = 0;
+        asm("cvt.sat.u16.s16 %0, %1;" : "=h"(res) : "h"(v));
+        return res;
     }
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(int v)
     {
-        return (ushort)((uint)v <= (uint)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0);
+        ushort res = 0;
+        asm("cvt.sat.u16.s32 %0, %1;" : "=h"(res) : "r"(v));
+        return res;
     }
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(uint v)
     {
-        return (ushort) ::min(v, (uint)USHRT_MAX);
+        ushort res = 0;
+        asm("cvt.sat.u16.u32 %0, %1;" : "=h"(res) : "r"(v));
+        return res;
     }
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(float v)
     {
-        int iv = __float2int_rn(v);
-        return saturate_cast<ushort>(iv);
+        ushort res = 0;
+        asm("cvt.rni.sat.u16.f32 %0, %1;" : "=h"(res) : "f"(v));
+        return res;
     }
     template<> __device__ __forceinline__ ushort saturate_cast<ushort>(double v)
     {
-    #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 130
-        int iv = __double2int_rn(v);
-        return saturate_cast<ushort>(iv);
+    #if __CUDA_ARCH__ >= 130
+        ushort res = 0;
+        asm("cvt.rni.sat.u16.f64 %0, %1;" : "=h"(res) : "d"(v));
+        return res;
     #else
         return saturate_cast<ushort>((float)v);
     #endif
@@ -161,31 +196,45 @@ namespace cv { namespace gpu { namespace device
 
     template<> __device__ __forceinline__ short saturate_cast<short>(ushort v)
     {
-        return (short) ::min((int)v, SHRT_MAX);
+        short res = 0;
+        asm("cvt.sat.s16.u16 %0, %1;" : "=h"(res) : "h"(v));
+        return res;
     }
     template<> __device__ __forceinline__ short saturate_cast<short>(int v)
     {
-        return (short)((uint)(v - SHRT_MIN) <= (uint)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN);
+        short res = 0;
+        asm("cvt.sat.s16.s32 %0, %1;" : "=h"(res) : "r"(v));
+        return res;
     }
     template<> __device__ __forceinline__ short saturate_cast<short>(uint v)
     {
-        return (short) ::min(v, (uint)SHRT_MAX);
+        short res = 0;
+        asm("cvt.sat.s16.u32 %0, %1;" : "=h"(res) : "r"(v));
+        return res;
     }
     template<> __device__ __forceinline__ short saturate_cast<short>(float v)
     {
-        int iv = __float2int_rn(v);
-        return saturate_cast<short>(iv);
+        short res = 0;
+        asm("cvt.rni.sat.s16.f32 %0, %1;" : "=h"(res) : "f"(v));
+        return res;
     }
     template<> __device__ __forceinline__ short saturate_cast<short>(double v)
     {
-    #if defined __CUDA_ARCH__ && __CUDA_ARCH__ >= 130
-        int iv = __double2int_rn(v);
-        return saturate_cast<short>(iv);
+    #if __CUDA_ARCH__ >= 130
+        short res = 0;
+        asm("cvt.rni.sat.s16.f64 %0, %1;" : "=h"(res) : "d"(v));
+        return res;
     #else
         return saturate_cast<short>((float)v);
     #endif
     }
 
+    template<> __device__ __forceinline__ int saturate_cast<int>(uint v)
+    {
+        int res = 0;
+        asm("cvt.sat.s32.u32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
+    }
     template<> __device__ __forceinline__ int saturate_cast<int>(float v)
     {
         return __float2int_rn(v);
@@ -199,6 +248,25 @@ namespace cv { namespace gpu { namespace device
     #endif
     }
 
+    template<> __device__ __forceinline__ uint saturate_cast<uint>(schar v)
+    {
+        uint res = 0;
+        int vi = v;
+        asm("cvt.sat.u32.s8 %0, %1;" : "=r"(res) : "r"(vi));
+        return res;
+    }
+    template<> __device__ __forceinline__ uint saturate_cast<uint>(short v)
+    {
+        uint res = 0;
+        asm("cvt.sat.u32.s16 %0, %1;" : "=r"(res) : "h"(v));
+        return res;
+    }
+    template<> __device__ __forceinline__ uint saturate_cast<uint>(int v)
+    {
+        uint res = 0;
+        asm("cvt.sat.u32.s32 %0, %1;" : "=r"(res) : "r"(v));
+        return res;
+    }
     template<> __device__ __forceinline__ uint saturate_cast<uint>(float v)
     {
         return __float2uint_rn(v);

From 60c0e41ba5a74ed87170c992a043bac9ddaaca2d Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 26 Nov 2012 17:22:47 +0400
Subject: [PATCH 099/155] integrate NMS (Dollar's criteria)

---
 modules/gpu/src/cuda/icf-sc.cu  | 29 +++++++++++++++++++----------
 modules/gpu/src/softcascade.cpp | 19 ++++++++++++++-----
 2 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 5334441d8..12b511fb0 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -88,19 +88,23 @@ namespace icf {
         return (w < 0 || h < 0)? 0.f : (float)(w * h);
     }
 
-    __global__ void overlap(const uint* n, const Detection* detections, uchar* overlaps)
+    texture<uint4,  cudaTextureType2D, cudaReadModeElementType> tdetections;
+
+    __global__ void overlap(const uint* n, uchar* overlaps)
     {
         const int idx = threadIdx.x;
         const int total = *n;
 
-        for (int i = idx; i < total; i += 192)
+        for (int i = idx + 1; i < total; i += 192)
         {
-            const Detection& a = detections[i];
+            const uint4 _a = tex2D(tdetections, i, 0);
+            const Detection& a = *((Detection*)(&_a));
             bool excluded = false;
 
             for (int j = i + 1; j < total; ++j)
             {
-                const Detection& b = detections[j];
+                const uint4 _b = tex2D(tdetections, j, 0);
+                const Detection& b = *((Detection*)(&_b));
                 float ovl = overlapArea(a, b) / ::min(a.w * a.h, b.w * b.h);
 
                 if (ovl > 0.65f)
@@ -115,7 +119,7 @@ namespace icf {
         }
     }
 
-    __global__ void collect(const uint* n, const Detection* detections, uchar* overlaps)
+    __global__ void collect(const uint* n, uchar* overlaps, uint* ctr, uint4* suppressed)
     {
         const int idx = threadIdx.x;
         const int total = *n;
@@ -124,19 +128,24 @@ namespace icf {
         {
             if (!overlaps[i])
             {
-                const Detection& det = detections[i];
-                // printf("%d: %d %d %d %d %f\n", i, det.x, det.y, det.w, det.h, det.confidence );
+                int oidx = atomicInc(ctr, 50);
+                suppressed[oidx] = tex2D(tdetections, i + 1, 0);
             }
         }
     }
 
-    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections)
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections, PtrStepSzb suppressed)
     {
         int block = 192;
         int grid = 1;
 
-        overlap<<<grid, block>>>((uint*)ndetections.ptr(0), (Detection*)objects.ptr(0), (uchar*)overlaps.ptr(0));
-        collect<<<grid, block>>>((uint*)ndetections.ptr(0), (Detection*)objects.ptr(0), (uchar*)overlaps.ptr(0));
+        cudaChannelFormatDesc desc = cudaCreateChannelDesc<uint4>();
+        size_t offset;
+        cudaSafeCall( cudaBindTexture2D(&offset, tdetections, objects.data, desc, objects.cols / sizeof(uint4), objects.rows, objects.step));
+
+        overlap<<<grid, block>>>((uint*)ndetections.ptr(0), (uchar*)overlaps.ptr(0));
+        collect<<<grid, block>>>((uint*)ndetections.ptr(0), (uchar*)overlaps.ptr(0), (uint*)suppressed.ptr(0), ((uint4*)suppressed.ptr(0)) + 1);
+
         // if (!stream)
         {
             cudaSafeCall( cudaGetLastError());
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 35bd72e55..5324e2e56 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -86,7 +86,7 @@ namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins, cudaStream_t stream);
 
-    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections);
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections, PtrStepSzb suppressed);
 }
 
 namespace imgproc {
@@ -312,6 +312,7 @@ struct cv::gpu::SCascade::Fields
         hogluv.setTo(cv::Scalar::all(0));
 
         overlaps.create(1, 5000, CV_8UC1);
+        suppressed.create(1, sizeof(Detection) * 51, CV_8UC1);
 
         return true;
     }
@@ -447,7 +448,9 @@ public:
     {
         ensureSizeIsEnough(objects.rows, objects.cols, CV_8UC1, overlaps);
         overlaps.setTo(0);
-        device::icf::suppress(objects, overlaps, ndetections);
+        suppressed.setTo(0);
+
+        device::icf::suppress(objects, overlaps, ndetections, suppressed);
         // std::cout << cv::Mat(overlaps) << std::endl;
     }
 
@@ -484,6 +487,9 @@ public:
     // used for area overlap computing during
     GpuMat overlaps;
 
+    // used for suppression
+    GpuMat suppressed;
+
     // Cascade from xml
     GpuMat octaves;
     GpuMat stages;
@@ -525,7 +531,6 @@ bool cv::gpu::SCascade::load(const FileNode& fn)
 void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, Stream& s) const
 {
     CV_Assert(fields);
-
     const GpuMat colored = image.getGpuMat();
 
     // only color images are supperted
@@ -545,6 +550,7 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
         colored.copyTo(flds.hogluv);
     }
 
+    GpuMat spr(objects, cv::Rect(0, 0, flds.suppressed.cols, flds.suppressed.rows));
 
     GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
     objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols - sizeof(Detection), 1));
@@ -552,8 +558,11 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
 
     flds.detect(rois, tmp, objects, stream);
 
-    // if (rejCriteria != NO_REJECT)
-    flds.suppress(tmp, objects);
+    if (rejCriteria != NO_REJECT)
+    {
+        flds.suppress(tmp, objects);
+        flds.suppressed.copyTo(spr);
+    }
 }
 
 void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const

From bd3179bda8035f3f349678aad2d1ae0510c52870 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 26 Nov 2012 17:53:25 +0400
Subject: [PATCH 100/155] fix CUDA support for streams for NMS; refactor tests

---
 modules/gpu/src/cuda/icf-sc.cu        | 13 +++---
 modules/gpu/src/icf.hpp               |  2 +-
 modules/gpu/src/softcascade.cpp       | 62 +++++++++++++++++----------
 modules/gpu/test/test_softcascade.cpp | 52 +++++++++++++---------
 4 files changed, 78 insertions(+), 51 deletions(-)

diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 12b511fb0..e32379950 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -134,7 +134,8 @@ namespace icf {
         }
     }
 
-    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections, PtrStepSzb suppressed)
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections,
+        PtrStepSzb suppressed, cudaStream_t stream)
     {
         int block = 192;
         int grid = 1;
@@ -146,7 +147,7 @@ namespace icf {
         overlap<<<grid, block>>>((uint*)ndetections.ptr(0), (uchar*)overlaps.ptr(0));
         collect<<<grid, block>>>((uint*)ndetections.ptr(0), (uchar*)overlaps.ptr(0), (uint*)suppressed.ptr(0), ((uint4*)suppressed.ptr(0)) + 1);
 
-        // if (!stream)
+        if (!stream)
         {
             cudaSafeCall( cudaGetLastError());
             cudaSafeCall( cudaDeviceSynchronize());
@@ -330,15 +331,15 @@ __global__ void soft_cascade(const CascadeInvoker<Policy> invoker, Detection* ob
 
 template<typename Policy>
 void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const cudaStream_t& stream) const
+    PtrStepSz<uchar4> objects, const int downscales, const cudaStream_t& stream) const
 {
     int fw = roi.rows;
     int fh = roi.cols;
 
     dim3 grid(fw, fh / Policy::STA_Y, downscales);
 
-    uint* ctr = (uint*)(counter.ptr(0));
-    Detection* det = (Detection*)objects.ptr();
+    uint* ctr = (uint*)(objects.ptr(0));
+    Detection* det = ((Detection*)objects.ptr(0)) + 1;
     uint max_det = objects.cols / sizeof(Detection);
 
     cudaChannelFormatDesc desc = cudaCreateChannelDesc<int>();
@@ -363,7 +364,7 @@ void CascadeInvoker<Policy>::operator()(const PtrStepSzb& roi, const PtrStepSzi&
 }
 
 template void CascadeInvoker<GK107PolicyX4>::operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv,
-    PtrStepSz<uchar4> objects, PtrStepSzi counter, const int downscales, const cudaStream_t& stream) const;
+    PtrStepSz<uchar4> objects, const int downscales, const cudaStream_t& stream) const;
 
 }
 }}}
\ No newline at end of file
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 454ac30da..06f99f2b1 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -147,7 +147,7 @@ struct CascadeInvoker
     int scales;
 
     void operator()(const PtrStepSzb& roi, const PtrStepSzi& hogluv, PtrStepSz<uchar4> objects,
-        PtrStepSzi counter, const int downscales, const cudaStream_t& stream = 0) const;
+        const int downscales, const cudaStream_t& stream = 0) const;
 
     template<bool isUp>
     __device void detect(Detection* objects, const uint ndetections, uint* ctr, const int downscales) const;
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 5324e2e56..37e7e3f4e 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -86,7 +86,8 @@ namespace icf {
     void fillBins(cv::gpu::PtrStepSzb hogluv, const cv::gpu::PtrStepSzf& nangle,
         const int fw, const int fh, const int bins, cudaStream_t stream);
 
-    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections, PtrStepSzb suppressed);
+    void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections,
+        PtrStepSzb suppressed, cudaStream_t stream);
 }
 
 namespace imgproc {
@@ -328,13 +329,20 @@ struct cv::gpu::SCascade::Fields
         leaves.upload(hleaves);
     }
 
-    void detect(const cv::gpu::GpuMat& roi, const cv::gpu::GpuMat& count, cv::gpu::GpuMat& objects, const cudaStream_t& stream) const
+    void detect(const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, Stream& s) const
     {
-        cudaMemset(count.data, 0, sizeof(Detection));
+        if (s)
+            s.enqueueMemSet(objects, 0);
+        else
+            cudaMemset(objects.data, 0, sizeof(Detection));
+
         cudaSafeCall( cudaGetLastError());
+
         device::icf::CascadeInvoker<device::icf::GK107PolicyX4> invoker
         = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, stages, nodes, leaves);
-        invoker(roi, hogluv, objects, count, downscales, stream);
+
+        cudaStream_t stream = StreamAccessor::getStream(s);
+        invoker(roi, hogluv, objects, downscales, stream);
     }
 
     void preprocess(const cv::gpu::GpuMat& colored, Stream& s)
@@ -356,6 +364,26 @@ struct cv::gpu::SCascade::Fields
         integrate(fh, fw, s);
     }
 
+    void suppress(GpuMat& objects, Stream& s)
+    {
+        GpuMat ndetections = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
+        ensureSizeIsEnough(objects.rows, objects.cols, CV_8UC1, overlaps);
+
+        if (s)
+        {
+            s.enqueueMemSet(overlaps, 0);
+            s.enqueueMemSet(suppressed, 0);
+        }
+        else
+        {
+            overlaps.setTo(0);
+            suppressed.setTo(0);
+        }
+
+        cudaStream_t stream = StreamAccessor::getStream(s);
+        device::icf::suppress(objects, overlaps, ndetections, suppressed, stream);
+    }
+
 private:
 
     typedef std::vector<device::icf::Octave>::const_iterator  octIt_t;
@@ -442,17 +470,7 @@ private:
         }
     }
 
-#include <iostream>
 public:
-    void suppress(GpuMat& ndetections, GpuMat& objects)
-    {
-        ensureSizeIsEnough(objects.rows, objects.cols, CV_8UC1, overlaps);
-        overlaps.setTo(0);
-        suppressed.setTo(0);
-
-        device::icf::suppress(objects, overlaps, ndetections, suppressed);
-        // std::cout << cv::Mat(overlaps) << std::endl;
-    }
 
     // scales range
     float minScale;
@@ -547,20 +565,18 @@ void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _
     }
     else
     {
-        colored.copyTo(flds.hogluv);
+        if (s)
+            s.enqueueCopy(colored, flds.hogluv);
+        else
+            colored.copyTo(flds.hogluv);
     }
 
-    GpuMat spr(objects, cv::Rect(0, 0, flds.suppressed.cols, flds.suppressed.rows));
-
-    GpuMat tmp = GpuMat(objects, cv::Rect(0, 0, sizeof(Detection), 1));
-    objects = GpuMat(objects, cv::Rect( sizeof(Detection), 0, objects.cols - sizeof(Detection), 1));
-    cudaStream_t stream = StreamAccessor::getStream(s);
-
-    flds.detect(rois, tmp, objects, stream);
+    flds.detect(rois, objects, s);
 
     if (rejCriteria != NO_REJECT)
     {
-        flds.suppress(tmp, objects);
+        GpuMat spr(objects, cv::Rect(0, 0, flds.suppressed.cols, flds.suppressed.rows));
+        flds.suppress(objects, s);
         flds.suppressed.copyTo(spr);
     }
 }
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index e36c28904..da97d4112 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -47,7 +47,7 @@
 using cv::gpu::GpuMat;
 
 // show detection results on input image with cv::imshow
-#define SHOW_DETECTIONS
+// #define SHOW_DETECTIONS
 
 #if defined SHOW_DETECTIONS
 # define SHOW(res)           \
@@ -99,6 +99,35 @@ namespace {
         return std::string(s);
     }
 
+    static void print(std::ostream &out, const Detection& d)
+    {
+#if defined SHOW_DETECTIONS
+        out << "\x1b[32m[ detection]\x1b[0m ("
+            << std::setw(4)  << d.x
+            << " "
+            << std::setw(4)  << d.y
+            << ") ("
+            << std::setw(4)  << d.w
+            << " "
+            << std::setw(4)  << d.h
+            << ") "
+            << std::setw(12) << d.confidence
+            <<  std::endl;
+#else
+        (void)out; (void)d;
+#endif
+    }
+
+    static void printTotal(std::ostream &out, int detbytes)
+    {
+#if defined SHOW_DETECTIONS
+        out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl;
+#else
+        (void)out; (void)detbytes;
+#endif
+    }
+
+#if defined SHOW_DETECTIONS
     static std::string getImageName(int level)
     {
         time_t rawtime;
@@ -112,32 +141,13 @@ namespace {
         return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
     }
 
-    static void print(std::ostream &out, const Detection& d)
-    {
-        out << "\x1b[32m[ detection]\x1b[0m ("
-            << std::setw(4)  << d.x
-            << " "
-            << std::setw(4)  << d.y
-            << ") ("
-            << std::setw(4)  << d.w
-            << " "
-            << std::setw(4)  << d.h
-            << ") "
-            << std::setw(12) << d.confidence
-            <<  std::endl;
-    }
-
-    static void printTotal(std::ostream &out, int detbytes)
-    {
-        out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl;
-    }
-
     static void writeResult(const cv::Mat& result, const int level)
     {
         std::string path = cv::tempfile(getImageName(level).c_str());
         cv::imwrite(path, result);
         std::cout << "\x1b[32m" << "[          ]" << std::endl << "[ stored in]"<< "\x1b[0m" << path << std::endl;
     }
+#endif
 }
 
 typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestRoi;

From 05cd88ae4233824a31072e1ed692ba80604ff51f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 26 Nov 2012 18:50:08 +0400
Subject: [PATCH 101/155] clean code; fix problems in documentation

---
 modules/gpu/doc/object_detection.rst    |  6 +--
 modules/gpu/include/opencv2/gpu/gpu.hpp |  4 +-
 modules/gpu/perf/perf_softcascade.cpp   | 35 -----------------
 modules/gpu/src/cuda/icf-sc.cu          |  2 +-
 modules/gpu/src/icf.hpp                 |  8 +---
 modules/gpu/src/softcascade.cpp         |  2 +-
 modules/gpu/test/test_softcascade.cpp   | 50 -------------------------
 7 files changed, 9 insertions(+), 98 deletions(-)

diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst
index c503d93fe..ce18892a1 100644
--- a/modules/gpu/doc/object_detection.rst
+++ b/modules/gpu/doc/object_detection.rst
@@ -200,7 +200,7 @@ The function is mainly used to learn the classifier.
 
 
 Soft Cascade Classifier
-======================
+==========================
 
 Soft Cascade Classifier for Object Detection
 ----------------------------------------------------------
@@ -226,7 +226,7 @@ The sample has been rejected if it fall rejection threshold. So stageless cascad
 
 SCascade
 ----------------
-.. ocv:class:: SCascade
+.. ocv:class:: SCascade : public Algorithm
 
 Implementation of soft (stageless) cascaded detector. ::
 
@@ -248,7 +248,7 @@ Implementation of soft (stageless) cascaded detector. ::
         virtual ~SCascade();
         virtual bool load(const FileNode& fn);
         virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
-        void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
+        virtual void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
     };
 
 
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 8362282b0..f0a9e99a0 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1586,7 +1586,7 @@ public:
     //    There non zero value mean that detector should be executed in this point.
     // Param mask is an output mask
     // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
-    void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
+    virtual void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
 
 private:
 
@@ -1600,6 +1600,8 @@ private:
     int rejCriteria;
 };
 
+CV_EXPORTS bool initModule_gpu(void);
+
 ////////////////////////////////// SURF //////////////////////////////////////////
 
 class CV_EXPORTS SURF_GPU
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 3e82cc5bb..ae816bcf5 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -33,18 +33,6 @@ namespace {
             else if (a.w != b.w) return a.w < b.w;
             else return a.h < b.h;
         }
-
-        // bool operator()(const cv::SoftCascade::Detection& a,
-        //     const cv::SoftCascade::Detection& b) const
-        // {
-        //     const cv::Rect& ra = a.rect;
-        //     const cv::Rect& rb = b.rect;
-
-        //     if (ra.x != rb.x) return ra.x < rb.x;
-        //     else if (ra.y != rb.y) return ra.y < rb.y;
-        //     else if (ra.width != rb.width) return ra.width < rb.width;
-        //     else return ra.height < rb.height;
-        // }
     };
 
     cv::Mat sortDetections(cv::gpu::GpuMat& objects)
@@ -99,29 +87,6 @@ RUN_GPU(SCascadeTest, detect)
 
 NO_CPU(SCascadeTest, detect)
 
-// RUN_CPU(SCascadeTest, detect)
-// {
-//     cv::Mat colored = readImage(GET_PARAM(1));
-//     ASSERT_FALSE(colored.empty());
-
-//     cv::SCascade cascade;
-//     ASSERT_TRUE(cascade.load(getDataPath(GET_PARAM(0))));
-
-//     std::vector<cv::Rect> rois;
-
-//     typedef cv::SCascade::Detection Detection;
-//     std::vector<Detection>objects;
-//     cascade.detectMultiScale(colored, rois, objects);
-
-//     TEST_CYCLE()
-//     {
-//         cascade.detectMultiScale(colored, rois, objects);
-//     }
-
-//     std::sort(objects.begin(), objects.end(), DetectionLess());
-//     SANITY_CHECK(objects);
-// }
-
 static cv::Rect getFromTable(int idx)
 {
     static const cv::Rect rois[] =
diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index e32379950..5fca87b4d 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -49,7 +49,7 @@
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
-    // ToDo: use textures or ancached load instruction.
+    // ToDo: use textures or uncached load instruction.
     __global__ void magToHist(const uchar* __restrict__ mag,
                               const float* __restrict__ angle, const int angPitch,
                                     uchar* __restrict__ hog,   const int hogPitch, const int fh)
diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 06f99f2b1..295255f57 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -45,7 +45,6 @@
 #define __OPENCV_ICF_HPP__
 
 #include <opencv2/gpu/device/common.hpp>
-#include <stdio.h>
 
 #if defined __CUDACC__
 # define __device __device__ __forceinline__
@@ -93,12 +92,7 @@ struct __align__(8) Node
 
     enum { THRESHOLD_MASK = 0x0FFFFFFF };
 
-    Node(const uchar4 r, const uint ch, const uint t) : rect(r), threshold(t + (ch << 28))
-    {
-        // printf("%d\n", t);
-        // printf("[%d %d %d %d] %d, %d\n",rect.x, rect.y, rect.z, rect.w, (int)(threshold >> 28),
-        //     (int)(0x0FFFFFFF & threshold));
-    }
+    Node(const uchar4 r, const uint ch, const uint t) : rect(r), threshold(t + (ch << 28)) {}
 };
 
 struct __align__(16) Detection
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 37e7e3f4e..2208369e6 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -142,7 +142,7 @@ struct cv::gpu::SCascade::Fields
         static const char * const SC_F_RECT             = "rect";
 
         FileNode fn = root[SC_OCTAVES];
-            if (fn.empty()) return false;
+        if (fn.empty()) return false;
 
         using namespace device::icf;
 
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index da97d4112..40bf5a0d6 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -205,56 +205,6 @@ GPU_TEST_P(SCascadeTestRoi, detect,
 
 }
 
-// typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestLevel;
-// GPU_TEST_P(SCascadeTestLevel, detect,
-//         testing::Combine(
-//         ALL_DEVICES,
-//         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-//         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-//         testing::Range(0, 47)
-//         ))
-// {
-//     cv::gpu::setDevice(GET_PARAM(0).deviceID());
-
-//     cv::gpu::SCascade cascade;
-
-//     cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-//     ASSERT_TRUE(fs.isOpened());
-
-//     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-//     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
-//     ASSERT_FALSE(coloredCpu.empty());
-
-//     typedef cv::gpu::SCascade::Detection Detection;
-//     GpuMat colored(coloredCpu), objectBoxes(1, 100 * sizeof(Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-//     rois.setTo(1);
-
-//     cv::gpu::GpuMat trois;
-//     cascade.genRoi(rois, trois);
-//     objectBoxes.setTo(0);
-//     int level = GET_PARAM(3);
-//     cascade.detect(colored, trois, objectBoxes, level);
-
-//     cv::Mat dt(objectBoxes);
-
-//     Detection* dts = ((Detection*)dt.data) + 1;
-//     int* count = dt.ptr<int>(0);
-
-//     cv::Mat result(coloredCpu);
-
-//     printTotal(std::cout, *count);
-//     for (int i = 0; i  < *count; ++i)
-//     {
-//         Detection d = dts[i];
-//         print(std::cout, d);
-//         cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
-//     }
-
-//     writeResult(result, level);
-//     SHOW(result);
-// }
-
 TEST(SCascadeTest, readCascade)
 {
     std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";

From 554a7cb33a8a487657e8ed7f980a20ddc2de1d4b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 12 Oct 2012 16:00:13 +0400
Subject: [PATCH 102/155] add epsilon in sanity checks

---
 modules/gpu/perf/perf_core.cpp | 879 +++++++--------------------------
 1 file changed, 176 insertions(+), 703 deletions(-)

diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index 725bb9b3d..1befcf929 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -28,27 +28,17 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::merge(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::merge(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-12);
     }
     else
     {
         cv::Mat dst;
 
-        cv::merge(src, dst);
+        TEST_CYCLE() cv::merge(src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::merge(src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-12);
     }
 }
 
@@ -69,28 +59,18 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
         std::vector<cv::gpu::GpuMat> d_dst;
 
-        cv::gpu::split(d_src, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::split(d_src, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::split(d_src, d_dst);
 
         cv::gpu::GpuMat first = d_dst[0];
-        GPU_SANITY_CHECK(first);
+        GPU_SANITY_CHECK(first, 1e-12);
     }
     else
     {
         std::vector<cv::Mat> dst;
 
-        cv::split(src, dst);
+        TEST_CYCLE() cv::split(src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::split(src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-12);
     }
 }
 
@@ -114,27 +94,17 @@ PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEP
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::add(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::add(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::add(src1, src2, dst);
+        TEST_CYCLE() cv::add(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::add(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -156,27 +126,17 @@ PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::add(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::add(d_src, s, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::add(src, s, dst);
+        TEST_CYCLE() cv::add(src, s, dst);
 
-        TEST_CYCLE()
-        {
-            cv::add(src, s, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -200,27 +160,17 @@ PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::subtract(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::subtract(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::subtract(src1, src2, dst);
+        TEST_CYCLE() cv::subtract(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::subtract(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -242,27 +192,17 @@ PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::subtract(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::subtract(d_src, s, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::subtract(src, s, dst);
+        TEST_CYCLE() cv::subtract(src, s, dst);
 
-        TEST_CYCLE()
-        {
-            cv::subtract(src, s, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -286,27 +226,17 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::multiply(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::multiply(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::multiply(src1, src2, dst);
+        TEST_CYCLE() cv::multiply(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::multiply(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -330,25 +260,17 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
         cv::gpu::multiply(d_src, s, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::multiply(d_src, s, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::multiply(src, s, dst);
+        TEST_CYCLE() cv::multiply(src, s, dst);
 
-        TEST_CYCLE()
-        {
-            cv::multiply(src, s, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -372,27 +294,17 @@ PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::divide(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::divide(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::divide(src1, src2, dst);
+        TEST_CYCLE() cv::divide(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::divide(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -414,27 +326,17 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_M
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::divide(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::divide(d_src, s, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::divide(src, s, dst);
+        TEST_CYCLE() cv::divide(src, s, dst);
 
-        TEST_CYCLE()
-        {
-            cv::divide(src, s, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -456,27 +358,17 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::divide(s, d_src, d_dst);
+        TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::divide(s, d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::divide(s, src, dst);
+        TEST_CYCLE() cv::divide(s, src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::divide(s, src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -500,27 +392,17 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::absdiff(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::absdiff(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::absdiff(src1, src2, dst);
+        TEST_CYCLE() cv::absdiff(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::absdiff(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -542,27 +424,17 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::absdiff(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::absdiff(d_src, s, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::absdiff(src, s, dst);
+        TEST_CYCLE() cv::absdiff(src, s, dst);
 
-        TEST_CYCLE()
-        {
-            cv::absdiff(src, s, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -582,19 +454,11 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::abs(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::abs(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
-    }
-    else
-    {
-        FAIL() << "No such CPU implementation analogy";
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
+    else FAIL_NO_CPU();
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -613,19 +477,11 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::sqr(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::sqr(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
-    }
-    else
-    {
-        FAIL() << "No such CPU implementation analogy";
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
+    else FAIL_NO_CPU();
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -644,27 +500,17 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::sqrt(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::sqrt(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::sqrt(src, dst);
+        TEST_CYCLE() cv::sqrt(src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::sqrt(src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -684,27 +530,17 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::log(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::log(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::log(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::log(src, dst);
+        TEST_CYCLE() cv::log(src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::log(src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -724,27 +560,17 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::exp(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::exp(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::exp(src, dst);
+        TEST_CYCLE() TEST_CYCLE() cv::exp(src, dst);
 
-        TEST_CYCLE()
-        {
-            cv::exp(src, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -767,27 +593,17 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::pow(d_src, power, d_dst);
+        TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::pow(d_src, power, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::pow(src, power, dst);
+        TEST_CYCLE() cv::pow(src, power,dst);
 
-        TEST_CYCLE()
-        {
-            cv::pow(src, power, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -817,12 +633,7 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
-        }
+        TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -830,12 +641,7 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
     {
         cv::Mat dst;
 
-        cv::compare(src1, src2, dst, cmp_code);
-
-        TEST_CYCLE()
-        {
-            cv::compare(src1, src2, dst, cmp_code);
-        }
+        TEST_CYCLE() cv::compare(src1, src2, dst, cmp_code);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -860,12 +666,7 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::compare(d_src, s, d_dst, cmp_code);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::compare(d_src, s, d_dst, cmp_code);
-        }
+        TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -873,12 +674,7 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR
     {
         cv::Mat dst;
 
-        cv::compare(src, s, dst, cmp_code);
-
-        TEST_CYCLE()
-        {
-            cv::compare(src, s, dst, cmp_code);
-        }
+        TEST_CYCLE() cv::compare(src, s, dst, cmp_code);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -900,12 +696,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_not(d_src, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_not(d_src, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -913,12 +704,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_
     {
         cv::Mat dst;
 
-        cv::bitwise_not(src, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_not(src, dst);
-        }
+        TEST_CYCLE() cv::bitwise_not(src,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -944,12 +730,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_and(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_and(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -957,12 +738,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
     {
         cv::Mat dst;
 
-        cv::bitwise_and(src1, src2, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_and(src1, src2, dst);
-        }
+        TEST_CYCLE() cv::bitwise_and(src1, src2,dst);
     }
 }
 
@@ -987,12 +763,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_and(d_src, s, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_and(d_src, s, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1000,12 +771,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
     {
         cv::Mat dst;
 
-        cv::bitwise_and(src, s, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_and(src, s, dst);
-        }
+        TEST_CYCLE() cv::bitwise_and(src, s,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1031,12 +797,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_or(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_or(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1044,12 +805,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
     {
         cv::Mat dst;
 
-        cv::bitwise_or(src1, src2, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_or(src1, src2, dst);
-        }
+        TEST_CYCLE() cv::bitwise_or(src1, src2,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1076,12 +832,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_or(d_src, s, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_or(d_src, s, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1089,12 +840,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va
     {
         cv::Mat dst;
 
-        cv::bitwise_or(src, s, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_or(src, s, dst);
-        }
+        TEST_CYCLE() cv::bitwise_or(src, s,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1120,12 +866,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_xor(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_xor(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1133,12 +874,7 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
     {
         cv::Mat dst;
 
-        cv::bitwise_xor(src1, src2, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_xor(src1, src2, dst);
-        }
+        TEST_CYCLE() cv::bitwise_xor(src1, src2,dst);
     }
 }
 
@@ -1163,12 +899,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::bitwise_xor(d_src, s, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::bitwise_xor(d_src, s, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1176,12 +907,7 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
     {
         cv::Mat dst;
 
-        cv::bitwise_xor(src, s, dst);
-
-        TEST_CYCLE()
-        {
-            cv::bitwise_xor(src, s, dst);
-        }
+        TEST_CYCLE() cv::bitwise_xor(src, s,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1208,18 +934,13 @@ PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::rshift(d_src, val, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::rshift(d_src, val, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -1244,18 +965,13 @@ PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::lshift(d_src, val, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::lshift(d_src, val, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -1279,12 +995,7 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::min(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::min(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1292,12 +1003,7 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
     {
         cv::Mat dst;
 
-        cv::min(src1, src2, dst);
-
-        TEST_CYCLE()
-        {
-            cv::min(src1, src2, dst);
-        }
+        TEST_CYCLE() cv::min(src1, src2,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1321,12 +1027,7 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::min(d_src, val, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::min(d_src, val, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1334,12 +1035,7 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
     {
         cv::Mat dst;
 
-        cv::min(src, val, dst);
-
-        TEST_CYCLE()
-        {
-            cv::min(src, val, dst);
-        }
+        TEST_CYCLE() cv::min(src, val,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1365,12 +1061,7 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::max(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::max(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1378,12 +1069,7 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
     {
         cv::Mat dst;
 
-        cv::max(src1, src2, dst);
-
-        TEST_CYCLE()
-        {
-            cv::max(src1, src2, dst);
-        }
+        TEST_CYCLE() cv::max(src1, src2,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1407,12 +1093,7 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::max(d_src, val, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::max(d_src, val, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1420,12 +1101,7 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
     {
         cv::Mat dst;
 
-        cv::max(src, val, dst);
-
-        TEST_CYCLE()
-        {
-            cv::max(src, val, dst);
-        }
+        TEST_CYCLE() cv::max(src, val,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1459,12 +1135,7 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
-        }
+        TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1472,12 +1143,7 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
     {
         cv::Mat dst;
 
-        cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
-
-        TEST_CYCLE()
-        {
-            cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
-        }
+        TEST_CYCLE() cv::addWeighted(src1, 0.5, src2, 0.5, 10.0, dst, dst_depth);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1518,29 +1184,19 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
         cv::gpu::GpuMat d_src3(src3);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
+        TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
-
         declare.time(50.0);
 
-        TEST_CYCLE()
-        {
-            cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
-        }
+        TEST_CYCLE() cv::gemm(src1, src2, 1.0, src3, 1.0, dst, flags);
 
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -1562,12 +1218,7 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::transpose(d_src, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::transpose(d_src, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1575,12 +1226,7 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
     {
         cv::Mat dst;
 
-        cv::transpose(src, dst);
-
-        TEST_CYCLE()
-        {
-            cv::transpose(src, dst);
-        }
+        TEST_CYCLE() cv::transpose(src,dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1616,12 +1262,7 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::flip(d_src, d_dst, flipCode);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::flip(d_src, d_dst, flipCode);
-        }
+        TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1629,12 +1270,7 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
     {
         cv::Mat dst;
 
-        cv::flip(src, dst, flipCode);
-
-        TEST_CYCLE()
-        {
-            cv::flip(src, dst, flipCode);
-        }
+        TEST_CYCLE() cv::flip(src, dst, flipCode);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1661,12 +1297,7 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::LUT(d_src, lut, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::LUT(d_src, lut, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1674,12 +1305,7 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
     {
         cv::Mat dst;
 
-        cv::LUT(src, lut, dst);
-
-        TEST_CYCLE()
-        {
-            cv::LUT(src, lut, dst);
-        }
+        TEST_CYCLE() cv::LUT(src, lut, dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1706,12 +1332,7 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::LUT(d_src, lut, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::LUT(d_src, lut, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
@@ -1719,12 +1340,7 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
     {
         cv::Mat dst;
 
-        cv::LUT(src, lut, dst);
-
-        TEST_CYCLE()
-        {
-            cv::LUT(src, lut, dst);
-        }
+        TEST_CYCLE() cv::LUT(src, lut, dst);
 
         CPU_SANITY_CHECK(dst);
     }
@@ -1745,14 +1361,9 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::magnitude(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::magnitude(d_src, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1761,14 +1372,9 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
 
         cv::Mat dst;
 
-        cv::magnitude(xy[0], xy[1], dst);
+        TEST_CYCLE() cv::magnitude(xy[0], xy[1], dst);
 
-        TEST_CYCLE()
-        {
-            cv::magnitude(xy[0], xy[1], dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -1787,18 +1393,13 @@ PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES)
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::magnitudeSqr(d_src, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::magnitudeSqr(d_src, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -1821,27 +1422,17 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::magnitude(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::magnitude(d_src1, d_src2, d_dst);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::magnitude(src1, src2, dst);
+        TEST_CYCLE() cv::magnitude(src1, src2, dst);
 
-        TEST_CYCLE()
-        {
-            cv::magnitude(src1, src2, dst);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
 
     }
 }
@@ -1865,18 +1456,13 @@ PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES)
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
-        }
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
 
         GPU_SANITY_CHECK(d_dst);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -1902,27 +1488,17 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
         cv::gpu::GpuMat d_src2(src2);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
+        TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
         cv::Mat dst;
 
-        cv::phase(src1, src2, dst, angleInDegrees);
+        TEST_CYCLE() cv::phase(src1, src2, dst, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::phase(src1, src2, dst, angleInDegrees);
-        }
-
-        CPU_SANITY_CHECK(dst);
+        CPU_SANITY_CHECK(dst, 1e-8);
     }
 }
 
@@ -1947,15 +1523,10 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES,
         cv::gpu::GpuMat d_magnitude;
         cv::gpu::GpuMat d_angle;
 
-        cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+        TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
-        }
-
-        GPU_SANITY_CHECK(d_magnitude);
-        GPU_SANITY_CHECK(d_angle);
+        GPU_SANITY_CHECK(d_magnitude, 1e-8);
+        GPU_SANITY_CHECK(d_angle, 1e-8);
 
     }
     else
@@ -1963,15 +1534,10 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES,
         cv::Mat magnitude;
         cv::Mat angle;
 
-        cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
+        TEST_CYCLE() cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::cartToPolar(src1, src2, magnitude, angle, angleInDegrees);
-        }
-
-        CPU_SANITY_CHECK(magnitude);
-        CPU_SANITY_CHECK(angle);
+        CPU_SANITY_CHECK(magnitude, 1e-8);
+        CPU_SANITY_CHECK(angle, 1e-8);
     }
 }
 
@@ -1996,30 +1562,20 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES,
         cv::gpu::GpuMat d_x;
         cv::gpu::GpuMat d_y;
 
-        cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
+        TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
-        }
-
-        GPU_SANITY_CHECK(d_x);
-        GPU_SANITY_CHECK(d_y);
+        GPU_SANITY_CHECK(d_x, 1e-8);
+        GPU_SANITY_CHECK(d_y, 1e-8);
     }
     else
     {
         cv::Mat x;
         cv::Mat y;
 
-        cv::polarToCart(magnitude, angle, x, y, angleInDegrees);
+        TEST_CYCLE() cv::polarToCart(magnitude, angle, x, y, angleInDegrees);
 
-        TEST_CYCLE()
-        {
-            cv::polarToCart(magnitude, angle, x, y, angleInDegrees);
-        }
-
-        CPU_SANITY_CHECK(x);
-        CPU_SANITY_CHECK(y);
+        CPU_SANITY_CHECK(x, 1e-8);
+        CPU_SANITY_CHECK(y, 1e-8);
     }
 }
 
@@ -2041,24 +1597,14 @@ PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES)
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
-        }
+        TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
     }
     else
     {
-        cv::meanStdDev(src, mean, stddev);
-
-        TEST_CYCLE()
-        {
-            cv::meanStdDev(src, mean, stddev);
-        }
+        TEST_CYCLE() cv::meanStdDev(src, mean, stddev);
     }
 
-    GPU_SANITY_CHECK(stddev);
+    GPU_SANITY_CHECK(stddev, 1e-6);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -2085,24 +1631,14 @@ PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        dst = cv::gpu::norm(d_src, normType, d_buf);
-
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::norm(d_src, normType, d_buf);
-        }
+        TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
     }
     else
     {
-        dst = cv::norm(src, normType);
-
-        TEST_CYCLE()
-        {
-            dst = cv::norm(src, normType);
-        }
+        TEST_CYCLE() dst = cv::norm(src, normType);
     }
 
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1e-6);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -2130,25 +1666,15 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine(
         cv::gpu::GpuMat d_src1(src1);
         cv::gpu::GpuMat d_src2(src2);
 
-        dst = cv::gpu::norm(d_src1, d_src2, normType);
-
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::norm(d_src1, d_src2, normType);
-        }
+        TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
 
     }
     else
     {
-        dst = cv::norm(src1, src2, normType);
-
-        TEST_CYCLE()
-        {
-            dst = cv::norm(src1, src2, normType);
-        }
+        TEST_CYCLE() dst = cv::norm(src1, src2, normType);
     }
 
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1e-6);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -2175,24 +1701,14 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        dst = cv::gpu::sum(d_src, d_buf);
-
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::sum(d_src, d_buf);
-        }
+        TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
     }
     else
     {
-        dst = cv::sum(src);
-
-        TEST_CYCLE()
-        {
-            dst = cv::sum(src);
-        }
+        TEST_CYCLE() dst = cv::sum(src);
     }
 
-    SANITY_CHECK(dst);
+    SANITY_CHECK(dst, 1e-6);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -2219,18 +1735,13 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        dst = cv::gpu::absSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
 
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::absSum(d_src, d_buf);
-        }
-
-        SANITY_CHECK(dst);
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -2258,18 +1769,13 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        dst = cv::gpu::sqrSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
 
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::sqrSum(d_src, d_buf);
-        }
-
-        SANITY_CHECK(dst);
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -2293,19 +1799,14 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
-        }
+        TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
 
         SANITY_CHECK(minVal);
         SANITY_CHECK(maxVal);
     }
     else
     {
-        FAIL() << "No such CPU implementation analogy";
+        FAIL_NO_CPU();
     }
 }
 
@@ -2330,25 +1831,15 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_valbuf, d_locbuf;
 
-        cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
-
-        TEST_CYCLE()
-        {
-            cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
-        }
+        TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
     }
     else
     {
-        cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
-
-        TEST_CYCLE()
-        {
-            cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
-        }
+        TEST_CYCLE() cv::minMaxLoc(src, &minVal, &maxVal, &minLoc, &maxLoc);
     }
 
-    SANITY_CHECK(minVal);
-    SANITY_CHECK(maxVal);
+    SANITY_CHECK(minVal, 1e-12);
+    SANITY_CHECK(maxVal, 1e-12);
 
     // unsupported by peft system
     //SANITY_CHECK(minLoc);
@@ -2375,21 +1866,11 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_buf;
 
-        dst = cv::gpu::countNonZero(d_src, d_buf);
-
-        TEST_CYCLE()
-        {
-            dst = cv::gpu::countNonZero(d_src, d_buf);
-        }
+        TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
     }
     else
     {
-        dst = cv::countNonZero(src);
-
-        TEST_CYCLE()
-        {
-            dst = cv::countNonZero(src);
-        }
+        TEST_CYCLE() dst = cv::countNonZero(src);
     }
 
     SANITY_CHECK(dst);
@@ -2430,25 +1911,17 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine(
         cv::gpu::GpuMat d_src(src);
         cv::gpu::GpuMat d_dst;
 
-        cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
+        TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
 
-        TEST_CYCLE()
-        {
-            cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
-        }
-
-        GPU_SANITY_CHECK(d_dst);
+        GPU_SANITY_CHECK(d_dst, 1);
     }
     else
     {
         cv::Mat dst;
 
-        cv::reduce(src, dst, dim, reduceOp);
+        TEST_CYCLE() cv::reduce(src, dst, dim, reduceOp);
 
-        TEST_CYCLE()
-        {
-            cv::reduce(src, dst, dim, reduceOp);
-        }
+        CPU_SANITY_CHECK(dst, 1);
     }
 }
 

From 22b0ea1cf0f620bc51aab9278252aeb9420350df Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 15 Oct 2012 20:07:24 +0400
Subject: [PATCH 103/155] sort for Hough sanity checks

---
 modules/gpu/perf/perf_imgproc.cpp | 40 +++++++++++++++++++++++++++----
 1 file changed, 35 insertions(+), 5 deletions(-)

diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 30377e148..2ecfd7dde 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -1706,10 +1706,30 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
     }
 }
 
+namespace {
+    struct Vec3fComparator
+    {
+        bool operator()(const cv::Vec3f& a, const cv::Vec3f b) const
+        {
+            if(a[0] != b[0]) return a[0] < b[0];
+            else if(a[1] != b[1]) return a[1] < b[1];
+            else return a[2] < b[2];
+        }
+    };
+    struct Vec2fComparator
+    {
+        bool operator()(const cv::Vec2f& a, const cv::Vec2f b) const
+        {
+            if(a[0] != b[0]) return a[0] < b[0];
+            else return a[1] < b[1];
+        }
+    };
+}
+
 //////////////////////////////////////////////////////////////////////
 // HoughLines
 
-PERF_TEST_P(Sz, DISABLED_ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
+PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
 {
     declare.time(30.0);
 
@@ -1744,7 +1764,11 @@ PERF_TEST_P(Sz, DISABLED_ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
             cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
         }
 
-        GPU_SANITY_CHECK(d_lines);
+        cv::Mat h_lines(d_lines);
+        cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
+        cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
+        std::sort(begin, end, Vec2fComparator());
+        SANITY_CHECK(h_lines);
     }
     else
     {
@@ -1756,7 +1780,8 @@ PERF_TEST_P(Sz, DISABLED_ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
             cv::HoughLines(src, lines, rho, theta, threshold);
         }
 
-        CPU_SANITY_CHECK(lines);
+        std::sort(lines.begin(), lines.end(), Vec2fComparator());
+        SANITY_CHECK(lines);
     }
 }
 
@@ -1804,7 +1829,11 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
             cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
         }
 
-        GPU_SANITY_CHECK(d_circles);
+        cv::Mat h_circles(d_circles);
+        cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
+        cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
+        std::sort(begin, end, Vec3fComparator());
+        SANITY_CHECK(h_circles);
     }
     else
     {
@@ -1817,7 +1846,8 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
             cv::HoughCircles(src, circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
         }
 
-        CPU_SANITY_CHECK(circles);
+        std::sort(circles.begin(), circles.end(), Vec3fComparator());
+        SANITY_CHECK(circles);
     }
 }
 

From 2eca75ccdd04f66e5be10acab20e62fbc4b90f84 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 27 Nov 2012 11:08:53 +0400
Subject: [PATCH 104/155] added common TransformFunctorTraits for element
 operations

---
 modules/gpu/src/cuda/element_operations.cu | 776 +++++----------------
 1 file changed, 164 insertions(+), 612 deletions(-)

diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index eaf577bac..071ad89ce 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -52,6 +52,103 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
+namespace
+{
+    template <size_t src_size, size_t dst_size> struct ArithmFuncTraits
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 1 };
+    };
+
+    template <> struct ArithmFuncTraits<1, 1>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<1, 2>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<1, 4>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct ArithmFuncTraits<2, 1>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<2, 2>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<2, 4>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+
+    template <> struct ArithmFuncTraits<4, 1>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<4, 2>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+    template <> struct ArithmFuncTraits<4, 4>
+    {
+        enum { simple_block_dim_x = 32 };
+        enum { simple_block_dim_y = 8 };
+
+        enum { smart_block_dim_x = 32 };
+        enum { smart_block_dim_y = 8 };
+        enum { smart_shift = 4 };
+    };
+}
+
 //////////////////////////////////////////////////////////////////////////
 // addMat
 
@@ -239,39 +336,20 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VAdd4<T, D> > : DefaultTransformFunctorTraits< VAdd4<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VAdd4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VAdd2<T, D> > : DefaultTransformFunctorTraits< VAdd4<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VAdd2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <> struct TransformFunctorTraits< AddMat<ushort, ushort> > : DefaultTransformFunctorTraits< AddMat<ushort, ushort> >
+    template <typename T, typename D> struct TransformFunctorTraits< AddMat<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddMat<short, short> > : DefaultTransformFunctorTraits< AddMat<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddMat<int, int> > : DefaultTransformFunctorTraits< AddMat<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddMat<float, float> > : DefaultTransformFunctorTraits< AddMat<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -385,25 +463,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< AddScalar<ushort, float, ushort> > : DefaultTransformFunctorTraits< AddScalar<ushort, float, ushort>  >
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< AddScalar<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<short, float, short> > : DefaultTransformFunctorTraits< AddScalar<short, float, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<int, float, int> > : DefaultTransformFunctorTraits< AddScalar<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddScalar<float, float, float> > : DefaultTransformFunctorTraits< AddScalar<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -664,39 +725,20 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VSub4<T, D> > : DefaultTransformFunctorTraits< VSub4<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VSub4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VSub2<T, D> > : DefaultTransformFunctorTraits< VSub2<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VSub2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <> struct TransformFunctorTraits< SubMat<ushort, ushort> > : DefaultTransformFunctorTraits< SubMat<ushort, ushort> >
+    template <typename T, typename D> struct TransformFunctorTraits< SubMat<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubMat<short, short> > : DefaultTransformFunctorTraits< SubMat<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubMat<int, int> > : DefaultTransformFunctorTraits< SubMat<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< SubMat<float, float> > : DefaultTransformFunctorTraits< SubMat<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -924,53 +966,16 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(Mul_8uc4_32f)
+    template <> struct TransformFunctorTraits<Mul_8uc4_32f> : ArithmFuncTraits<sizeof(uint), sizeof(uint)>
     {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
     };
 
-    template <> struct TransformFunctorTraits< Mul<ushort, ushort> > : DefaultTransformFunctorTraits< Mul<ushort, ushort> >
+    template <typename T, typename D> struct TransformFunctorTraits< Mul<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Mul<short, short> > : DefaultTransformFunctorTraits< Mul<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Mul<int, int> > : DefaultTransformFunctorTraits< Mul<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Mul<float, float> > : DefaultTransformFunctorTraits< Mul<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 
-    template <> struct TransformFunctorTraits< MulScale<ushort, float, ushort> > : DefaultTransformFunctorTraits< MulScale<ushort, float, ushort> >
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< MulScale<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScale<short, float, short> > : DefaultTransformFunctorTraits< MulScale<short, float, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScale<int, float, int> > : DefaultTransformFunctorTraits< MulScale<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScale<float, float, float> > : DefaultTransformFunctorTraits< MulScale<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1078,25 +1083,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< MulScalar<ushort, float, ushort> > : DefaultTransformFunctorTraits< MulScalar<ushort, float, ushort> >
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< MulScalar<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScalar<short, float, short> > : DefaultTransformFunctorTraits< MulScalar<short, float, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScalar<int, float, int> > : DefaultTransformFunctorTraits< MulScalar<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< MulScalar<float, float, float> > : DefaultTransformFunctorTraits< MulScalar<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1246,53 +1234,16 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    OPENCV_GPU_TRANSFORM_FUNCTOR_TRAITS(Div_8uc4_32f)
+    template <> struct TransformFunctorTraits<Div_8uc4_32f> : ArithmFuncTraits<sizeof(uint), sizeof(uint)>
     {
-        enum { smart_block_dim_x = 8 };
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 8 };
     };
 
-    template <> struct TransformFunctorTraits< Div<ushort, ushort> > : DefaultTransformFunctorTraits< Div<ushort, ushort> >
+    template <typename T, typename D> struct TransformFunctorTraits< Div<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Div<short, short> > : DefaultTransformFunctorTraits< Div<short, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Div<int, int> > : DefaultTransformFunctorTraits< Div<int, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Div<float, float> > : DefaultTransformFunctorTraits< Div<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 
-    template <> struct TransformFunctorTraits< DivScale<ushort, float, ushort> > : DefaultTransformFunctorTraits< DivScale<ushort, float, ushort> >
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< DivScale<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivScale<short, float, short> > : DefaultTransformFunctorTraits< DivScale<short, float, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivScale<int, float, int> > : DefaultTransformFunctorTraits< DivScale<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivScale<float, float, float> > : DefaultTransformFunctorTraits< DivScale<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1469,25 +1420,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< DivInv<ushort, float, ushort> > : DefaultTransformFunctorTraits< DivInv<ushort, float, ushort> >
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< DivInv<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivInv<short, float, short> > : DefaultTransformFunctorTraits< DivInv<short, float, short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivInv<int, float, int> > : DefaultTransformFunctorTraits< DivInv<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< DivInv<float, float, float> > : DefaultTransformFunctorTraits< DivInv<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1677,39 +1611,20 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff4<T, D> > : DefaultTransformFunctorTraits< VAbsDiff4<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff2<T, D> > : DefaultTransformFunctorTraits< VAbsDiff4<T, D> >
+    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
-        enum { smart_shift = 2 };
     };
 
     ////////////////////////////////////
 
-    template <> struct TransformFunctorTraits< AbsDiffMat<ushort> > : DefaultTransformFunctorTraits< AbsDiffMat<ushort> >
+    template <typename T> struct TransformFunctorTraits< AbsDiffMat<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffMat<short> > : DefaultTransformFunctorTraits< AbsDiffMat<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffMat<int> > : DefaultTransformFunctorTraits< AbsDiffMat<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffMat<float> > : DefaultTransformFunctorTraits< AbsDiffMat<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1769,25 +1684,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< AbsDiffScalar<ushort, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<ushort, float>  >
+    template <typename T, typename S> struct TransformFunctorTraits< AbsDiffScalar<T, S> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffScalar<short, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<short, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffScalar<int, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<int, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AbsDiffScalar<float, float> > : DefaultTransformFunctorTraits< AbsDiffScalar<float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1815,25 +1713,8 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< abs_func<ushort> > : DefaultTransformFunctorTraits< abs_func<ushort> >
+    template <typename T> struct TransformFunctorTraits< abs_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< abs_func<short> > : DefaultTransformFunctorTraits< abs_func<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< abs_func<int> > : DefaultTransformFunctorTraits< abs_func<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< abs_func<float> > : DefaultTransformFunctorTraits< abs_func<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1873,25 +1754,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< Sqr<ushort> > : DefaultTransformFunctorTraits< Sqr<ushort> >
+    template <typename T> struct TransformFunctorTraits< Sqr<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Sqr<short> > : DefaultTransformFunctorTraits< Sqr<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Sqr<int> > : DefaultTransformFunctorTraits< Sqr<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Sqr<float> > : DefaultTransformFunctorTraits< Sqr<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1917,33 +1781,8 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< sqrt_func<uchar> > : DefaultTransformFunctorTraits< sqrt_func<ushort> >
+    template <typename T> struct TransformFunctorTraits< sqrt_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< sqrt_func<schar> > : DefaultTransformFunctorTraits< sqrt_func<schar> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< sqrt_func<ushort> > : DefaultTransformFunctorTraits< sqrt_func<ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< sqrt_func<short> > : DefaultTransformFunctorTraits< sqrt_func<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< sqrt_func<int> > : DefaultTransformFunctorTraits< sqrt_func<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< sqrt_func<float> > : DefaultTransformFunctorTraits< sqrt_func<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -1969,33 +1808,8 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< log_func<uchar> > : DefaultTransformFunctorTraits< log_func<ushort> >
+    template <typename T> struct TransformFunctorTraits< log_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< log_func<schar> > : DefaultTransformFunctorTraits< log_func<schar> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< log_func<ushort> > : DefaultTransformFunctorTraits< log_func<ushort> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< log_func<short> > : DefaultTransformFunctorTraits< log_func<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< log_func<int> > : DefaultTransformFunctorTraits< log_func<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< log_func<float> > : DefaultTransformFunctorTraits< log_func<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -2036,25 +1850,8 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< Exp<ushort> > : DefaultTransformFunctorTraits< Exp<ushort> >
+    template <typename T> struct TransformFunctorTraits< Exp<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Exp<short> > : DefaultTransformFunctorTraits< Exp<short> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Exp<int> > : DefaultTransformFunctorTraits< Exp<int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< Exp<float> > : DefaultTransformFunctorTraits< Exp<float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -2080,12 +1877,12 @@ namespace arithm
 
 namespace
 {
-    template <template <typename> class Op, typename T>
-    struct Cmp: binary_function<T, T, uchar>
+    template <class Op, typename T>
+    struct Cmp : binary_function<T, T, uchar>
     {
         __device__ __forceinline__ uchar operator()(T a, T b) const
         {
-            Op<T> op;
+            Op op;
             return -op(a, b);
         }
     };
@@ -2093,27 +1890,9 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    #define IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(op, type, block_dim_y, shift) \
-        template <> struct TransformFunctorTraits< Cmp<op, type> > : DefaultTransformFunctorTraits< Cmp<op, type> > \
-        { \
-            enum { smart_block_dim_y = block_dim_y }; \
-            enum { smart_shift = shift }; \
-        };
-
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(not_equal_to, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(not_equal_to, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater_equal, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater_equal, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, float, 8, 4)
-
-    #undef IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS
+    template <class Op, typename T> struct TransformFunctorTraits< Cmp<Op, T> > : ArithmFuncTraits<sizeof(T), sizeof(uchar)>
+    {
+    };
 }}}
 
 namespace arithm
@@ -2121,7 +1900,7 @@ namespace arithm
     template <template <typename> class Op, typename T>
     void cmpMat(PtrStepSzb src1, PtrStepSzb src2, PtrStepSzb dst, cudaStream_t stream)
     {
-        Cmp<Op, T> op;
+        Cmp<Op<T>, T> op;
         transform((PtrStepSz<T>) src1, (PtrStepSz<T>) src2, dst, op, WithOutMask(), stream);
     }
 
@@ -2182,8 +1961,8 @@ namespace
 {
 #define TYPE_VEC(type, cn) typename TypeVec<type, cn>::vec_type
 
-    template <template <typename> class Op, typename T, int cn> struct CmpScalar;
-    template <template <typename> class Op, typename T>
+    template <class Op, typename T, int cn> struct CmpScalar;
+    template <class Op, typename T>
     struct CmpScalar<Op, T, 1> : unary_function<T, uchar>
     {
         const T val;
@@ -2196,7 +1975,7 @@ namespace
             return op(src, val);
         }
     };
-    template <template <typename> class Op, typename T>
+    template <class Op, typename T>
     struct CmpScalar<Op, T, 2> : unary_function<TYPE_VEC(T, 2), TYPE_VEC(uchar, 2)>
     {
         const TYPE_VEC(T, 2) val;
@@ -2209,7 +1988,7 @@ namespace
             return VecTraits<TYPE_VEC(uchar, 2)>::make(op(src.x, val.x), op(src.y, val.y));
         }
     };
-    template <template <typename> class Op, typename T>
+    template <class Op, typename T>
     struct CmpScalar<Op, T, 3> : unary_function<TYPE_VEC(T, 3), TYPE_VEC(uchar, 3)>
     {
         const TYPE_VEC(T, 3) val;
@@ -2222,7 +2001,7 @@ namespace
             return VecTraits<TYPE_VEC(uchar, 3)>::make(op(src.x, val.x), op(src.y, val.y), op(src.z, val.z));
         }
     };
-    template <template <typename> class Op, typename T>
+    template <class Op, typename T>
     struct CmpScalar<Op, T, 4> : unary_function<TYPE_VEC(T, 4), TYPE_VEC(uchar, 4)>
     {
         const TYPE_VEC(T, 4) val;
@@ -2241,27 +2020,9 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-#define IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(op, type, block_dim_y, shift) \
-    template <> struct TransformFunctorTraits< CmpScalar<op, type, 1> > : DefaultTransformFunctorTraits< CmpScalar<op, type, 1> > \
-    { \
-        enum { smart_block_dim_y = block_dim_y }; \
-        enum { smart_shift = shift }; \
+    template <class Op, typename T> struct TransformFunctorTraits< CmpScalar<Op, T, 1> > : ArithmFuncTraits<sizeof(T), sizeof(uchar)>
+    {
     };
-
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(equal_to, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(not_equal_to, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(not_equal_to, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater_equal, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(greater_equal, float, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, int, 8, 4)
-    IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS(less_equal, float, 8, 4)
-
-#undef IMPLEMENT_COMPARE_TRANSFORM_FUNCTOR_TRAITS
 }}}
 
 namespace arithm
@@ -2275,7 +2036,7 @@ namespace arithm
         T sval[] = {static_cast<T>(val[0]), static_cast<T>(val[1]), static_cast<T>(val[2]), static_cast<T>(val[3])};
         src_t val1 = VecTraits<src_t>::make(sval);
 
-        CmpScalar<Op, T, cn> op(val1);
+        CmpScalar<Op<T>, T, cn> op(val1);
         transform((PtrStepSz<src_t>) src, (PtrStepSz<dst_t>) dst, op, WithOutMask(), stream);
     }
 
@@ -2418,56 +2179,20 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< bit_not<uchar> > : DefaultTransformFunctorTraits< bit_not<uchar> >
+    template <typename T> struct TransformFunctorTraits< bit_not<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_not<ushort> > : DefaultTransformFunctorTraits< bit_not<ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_not<uint> > : DefaultTransformFunctorTraits< bit_not<uint> >
-    {
-        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< bit_and<uchar> > : DefaultTransformFunctorTraits< bit_and<uchar> >
+    template <typename T> struct TransformFunctorTraits< bit_and<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_and<ushort> > : DefaultTransformFunctorTraits< bit_and<ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_and<uint> > : DefaultTransformFunctorTraits< bit_and<uint> >
-    {
-        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< bit_or<uchar> > : DefaultTransformFunctorTraits< bit_or<uchar> >
+    template <typename T> struct TransformFunctorTraits< bit_or<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_or<ushort> > : DefaultTransformFunctorTraits< bit_or<ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_or<uint> > : DefaultTransformFunctorTraits< bit_or<uint> >
-    {
-        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< bit_xor<uchar> > : DefaultTransformFunctorTraits< bit_xor<uchar> >
+    template <typename T> struct TransformFunctorTraits< bit_xor<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_xor<ushort> > : DefaultTransformFunctorTraits< bit_xor<ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< bit_xor<uint> > : DefaultTransformFunctorTraits< bit_xor<uint> >
-    {
-        enum { smart_shift = 2 };
     };
 }}}
 
@@ -2527,43 +2252,16 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< binder2nd< bit_and<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<uchar> > >
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_and<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_and<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<ushort> > >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_and<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_and<uint> > >
-    {
-        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< binder2nd< bit_or<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<uchar> > >
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_or<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_or<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<ushort> > >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_or<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_or<uint> > >
-    {
-        enum { smart_shift = 2 };
     };
 
-    template <> struct TransformFunctorTraits< binder2nd< bit_xor<uchar> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<uchar> > >
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_xor<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_xor<ushort> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<ushort> > >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< bit_xor<uint> > > : DefaultTransformFunctorTraits< binder2nd< bit_xor<uint> > >
-    {
-        enum { smart_shift = 2 };
     };
 }}}
 
@@ -2691,58 +2389,24 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< VMin4<T> > : DefaultTransformFunctorTraits< VMin4<T> >
+    template <typename T> struct TransformFunctorTraits< VMin4<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-                enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< VMin2<T> > : DefaultTransformFunctorTraits< VMin2<T> >
+    template <typename T> struct TransformFunctorTraits< VMin2<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-                enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
     ////////////////////////////////////
 
-    template <> struct TransformFunctorTraits< minimum<ushort> > : DefaultTransformFunctorTraits< minimum<ushort> >
+    template <typename T> struct TransformFunctorTraits< minimum<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< minimum<short> > : DefaultTransformFunctorTraits< minimum<short> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< minimum<int> > : DefaultTransformFunctorTraits< minimum<int> >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< minimum<float> > : DefaultTransformFunctorTraits< minimum<float> >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
-    template <> struct TransformFunctorTraits< binder2nd< minimum<ushort> > > : DefaultTransformFunctorTraits< binder2nd< minimum<ushort> > >
+    template <typename T> struct TransformFunctorTraits< binder2nd< minimum<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< minimum<short> > > : DefaultTransformFunctorTraits< binder2nd< minimum<short> > >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< minimum<int> > > : DefaultTransformFunctorTraits< binder2nd< minimum<int> > >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< minimum<float> > > : DefaultTransformFunctorTraits< binder2nd< minimum<float> > >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -2885,58 +2549,24 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< VMax4<T> > : DefaultTransformFunctorTraits< VMax4<T> >
+    template <typename T> struct TransformFunctorTraits< VMax4<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< VMax2<T> > : DefaultTransformFunctorTraits< VMax2<T> >
+    template <typename T> struct TransformFunctorTraits< VMax2<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
     ////////////////////////////////////
 
-    template <> struct TransformFunctorTraits< maximum<ushort> > : DefaultTransformFunctorTraits< maximum<ushort> >
+    template <typename T> struct TransformFunctorTraits< maximum<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< maximum<short> > : DefaultTransformFunctorTraits< maximum<short> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< maximum<int> > : DefaultTransformFunctorTraits< maximum<int> >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< maximum<float> > : DefaultTransformFunctorTraits< maximum<float> >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 
-    template <> struct TransformFunctorTraits< binder2nd< maximum<ushort> > > : DefaultTransformFunctorTraits< binder2nd< maximum<ushort> > >
+    template <typename T> struct TransformFunctorTraits< binder2nd< maximum<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< maximum<short> > > : DefaultTransformFunctorTraits< binder2nd< maximum<short> > >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< maximum<int> > > : DefaultTransformFunctorTraits< binder2nd< maximum<int> > >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< binder2nd< maximum<float> > > : DefaultTransformFunctorTraits< binder2nd< maximum<float> > >
-    {
-        enum { smart_block_dim_y = 4 };
-        enum { smart_shift = 4 };
     };
 }}}
 
@@ -2990,35 +2620,23 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    namespace detail
+    template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
-        template <size_t size, typename F> struct ThresholdTraits : DefaultTransformFunctorTraits<F>
-        {
-        };
-        template <typename F> struct ThresholdTraits<2, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename F> struct ThresholdTraits<4, F> : DefaultTransformFunctorTraits<F>
-        {
-            enum { smart_block_dim_y = 4 };
-            enum { smart_shift = 4 };
-        };
-    }
+    };
 
-    template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_binary_func<T> >
+    template <typename T> struct TransformFunctorTraits< thresh_binary_inv_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
-    template <typename T> struct TransformFunctorTraits< thresh_binary_inv_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_binary_inv_func<T> >
+
+    template <typename T> struct TransformFunctorTraits< thresh_trunc_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
-    template <typename T> struct TransformFunctorTraits< thresh_trunc_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_trunc_func<T> >
+
+    template <typename T> struct TransformFunctorTraits< thresh_to_zero_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_to_zero_func<T> >
-    {
-    };
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : detail::ThresholdTraits< sizeof(T), thresh_to_zero_inv_func<T> >
+
+    template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -3116,28 +2734,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    namespace detail
-    {
-        template <size_t size, typename T> struct PowOpTraits : DefaultTransformFunctorTraits< PowOp<T> >
-        {
-        };
-        template <typename T> struct PowOpTraits<1, T> : DefaultTransformFunctorTraits< PowOp<T> >
-        {
-            enum { smart_block_dim_y = 8 };
-            enum { smart_shift = 8 };
-        };
-        template <typename T> struct PowOpTraits<2, T> : DefaultTransformFunctorTraits< PowOp<T> >
-        {
-            enum { smart_shift = 4 };
-        };
-        template <typename T> struct PowOpTraits<4, T> : DefaultTransformFunctorTraits< PowOp<T> >
-        {
-            enum { smart_block_dim_y = 4 };
-            enum { smart_shift = 4 };
-        };
-    }
-
-    template <typename T> struct TransformFunctorTraits< PowOp<T> > : detail::PowOpTraits<sizeof(T), T>
+    template <typename T> struct TransformFunctorTraits< PowOp<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -3212,60 +2809,15 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, ushort> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, ushort> >
+    template <typename T1, typename T2, typename D, size_t src1_size, size_t src2_size, size_t dst_size> struct AddWeightedTraits : DefaultTransformFunctorTraits< AddWeighted<T1, T2, D> >
     {
-        enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, ushort, short> > : DefaultTransformFunctorTraits< AddWeighted<ushort, ushort, short> >
+    template <typename T1, typename T2, typename D, size_t src_size, size_t dst_size> struct AddWeightedTraits<T1, T2, D, src_size, src_size, dst_size> : ArithmFuncTraits<src_size, dst_size>
     {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, short, ushort> > : DefaultTransformFunctorTraits< AddWeighted<ushort, short, ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<ushort, short, short> > : DefaultTransformFunctorTraits< AddWeighted<ushort, short, short> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<short, short, ushort> > : DefaultTransformFunctorTraits< AddWeighted<short, short, ushort> >
-    {
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<short, short, short> > : DefaultTransformFunctorTraits< AddWeighted<short, short, short> >
-    {
-        enum { smart_shift = 4 };
     };
 
-    template <> struct TransformFunctorTraits< AddWeighted<int, int, int> > : DefaultTransformFunctorTraits< AddWeighted<int, int, int> >
+    template <typename T1, typename T2, typename D> struct TransformFunctorTraits< AddWeighted<T1, T2, D> > : AddWeightedTraits<T1, T2, D, sizeof(T1), sizeof(T2), sizeof(D)>
     {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<int, int, float> > : DefaultTransformFunctorTraits< AddWeighted<int, int, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<int, float, int> > : DefaultTransformFunctorTraits< AddWeighted<int, float, int> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<int, float, float> > : DefaultTransformFunctorTraits< AddWeighted<int, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<float, float, int> > : DefaultTransformFunctorTraits< AddWeighted<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
-    };
-    template <> struct TransformFunctorTraits< AddWeighted<float, float, float> > : DefaultTransformFunctorTraits< AddWeighted<float, float, float> >
-    {
-        enum { smart_block_dim_y = 8 };
-        enum { smart_shift = 4 };
     };
 }}}
 

From 0b2c1dc871d0a9f1fd439d949780edf749de33cd Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 27 Nov 2012 18:43:17 +0400
Subject: [PATCH 105/155] fixed build without CUDA

---
 modules/gpu/perf/perf_softcascade.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index ae816bcf5..b4091d09b 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -284,9 +284,11 @@ RUN_GPU(SCascadeTest, detectStream)
         cascade.detect(colored, trois, objectBoxes, s);
     }
 
+#ifdef HAVE_CUDA
     cudaDeviceSynchronize();
+#endif
 
     SANITY_CHECK(sortDetections(objectBoxes));
 }
 
-NO_CPU(SCascadeTest, detectStream)
\ No newline at end of file
+NO_CPU(SCascadeTest, detectStream)

From 1d97a4549da3a601c3b67b8b63e84c4ebfb9d36f Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 03:48:54 +0400
Subject: [PATCH 106/155] fixed compilation for GCC 4.6

---
 modules/gpu/include/opencv2/gpu/device/functional.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/functional.hpp b/modules/gpu/include/opencv2/gpu/device/functional.hpp
index cd63c3ac9..6064e8e99 100644
--- a/modules/gpu/include/opencv2/gpu/device/functional.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/functional.hpp
@@ -375,7 +375,7 @@ namespace cv { namespace gpu { namespace device
     {
         __device__ __forceinline__ signed char operator ()(signed char x) const
         {
-            return ::abs(x);
+            return ::abs((int)x);
         }
 
         __device__ __forceinline__ abs_func() {}
@@ -385,7 +385,7 @@ namespace cv { namespace gpu { namespace device
     {
         __device__ __forceinline__ char operator ()(char x) const
         {
-            return ::abs(x);
+            return ::abs((int)x);
         }
 
         __device__ __forceinline__ abs_func() {}
@@ -405,7 +405,7 @@ namespace cv { namespace gpu { namespace device
     {
         __device__ __forceinline__ short operator ()(short x) const
         {
-            return ::abs(x);
+            return ::abs((int)x);
         }
 
         __device__ __forceinline__ abs_func() {}

From d985861462565c3aa4ee044d22b36c9fdd74e260 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 03:50:49 +0400
Subject: [PATCH 107/155] remove unused std imports

---
 modules/gpu/include/opencv2/gpu/device/emulation.hpp | 1 -
 modules/gpu/src/cuda/optical_flow_farneback.cu       | 3 ---
 modules/gpu/src/nvidia/core/NCV.cu                   | 8 +++-----
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/emulation.hpp b/modules/gpu/include/opencv2/gpu/device/emulation.hpp
index 074e91127..b6fba230e 100644
--- a/modules/gpu/include/opencv2/gpu/device/emulation.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/emulation.hpp
@@ -44,7 +44,6 @@
 #define OPENCV_GPU_EMULATION_HPP_
 
 #include "warp_reduce.hpp"
-#include <stdio.h>
 
 namespace cv { namespace gpu { namespace device
 {
diff --git a/modules/gpu/src/cuda/optical_flow_farneback.cu b/modules/gpu/src/cuda/optical_flow_farneback.cu
index 8231775b8..5bbca34f1 100644
--- a/modules/gpu/src/cuda/optical_flow_farneback.cu
+++ b/modules/gpu/src/cuda/optical_flow_farneback.cu
@@ -42,7 +42,6 @@
 
 #if !defined CUDA_DISABLER
 
-#include <stdio.h>
 #include "internal_shared.hpp"
 #include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/border_interpolate.hpp"
@@ -57,8 +56,6 @@
 #define BORDER_SIZE 5
 #define MAX_KSIZE_HALF 100
 
-using namespace std;
-
 namespace cv { namespace gpu { namespace device { namespace optflow_farneback
 {
     __constant__ float c_g[8];
diff --git a/modules/gpu/src/nvidia/core/NCV.cu b/modules/gpu/src/nvidia/core/NCV.cu
index 5d1b5d12c..77e59cc5c 100644
--- a/modules/gpu/src/nvidia/core/NCV.cu
+++ b/modules/gpu/src/nvidia/core/NCV.cu
@@ -45,8 +45,6 @@
 #include <vector>
 #include "NCV.hpp"
 
-using namespace std;
-
 
 //==============================================================================
 //
@@ -55,16 +53,16 @@ using namespace std;
 //==============================================================================
 
 
-static void stdDebugOutput(const string &msg)
+static void stdDebugOutput(const std::string &msg)
 {
-    cout << msg;
+    std::cout << msg;
 }
 
 
 static NCVDebugOutputHandler *debugOutputHandler = stdDebugOutput;
 
 
-void ncvDebugOutput(const string &msg)
+void ncvDebugOutput(const std::string &msg)
 {
     debugOutputHandler(msg);
 }

From 2e0161c6c5f4f352e879575adba8dced77b75ec2 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 10:50:33 +0400
Subject: [PATCH 108/155] create objects mat if empty

---
 modules/gpu/src/softcascade.cpp       | 32 ++++++++++++++++-----------
 modules/gpu/test/test_softcascade.cpp |  2 +-
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 2208369e6..1ccfa3a9d 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -519,6 +519,8 @@ public:
 
     GpuMat collected;
 
+    cv::gpu::GpuMat genRoiTmp;
+
     std::vector<device::icf::Octave> voctaves;
 
     DeviceInfo info;
@@ -546,29 +548,33 @@ bool cv::gpu::SCascade::load(const FileNode& fn)
     return fields != 0;
 }
 
-void cv::gpu::SCascade::detect(InputArray image, InputArray _rois, OutputArray _objects, Stream& s) const
+void cv::gpu::SCascade::detect(InputArray _image, InputArray _rois, OutputArray _objects, Stream& s) const
 {
     CV_Assert(fields);
-    const GpuMat colored = image.getGpuMat();
 
-    // only color images are supperted
-    CV_Assert(colored.type() == CV_8UC3 || colored.type() == CV_32SC1);
+    // only color images and precomputed integrals are supported
+    int type = _image.type();
+    CV_Assert(type == CV_8UC3 || type == CV_32SC1 || (!_rois.empty()));
+
+    const GpuMat image = _image.getGpuMat();
+
+    if (_objects.empty()) _objects.create(1, 4096 * sizeof(Detection), CV_8UC1);
 
     GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
-    Fields& flds = *fields;
 
-    if (colored.type() == CV_8UC3)
+    Fields& flds = *fields;
+    if (type == CV_8UC3)
     {
-        if (!flds.update(colored.rows, colored.cols, flds.shrinkage) || flds.check(minScale, maxScale, scales))
-            flds.createLevels(colored.rows, colored.cols);
-        flds.preprocess(colored, s);
+        if (!flds.update(image.rows, image.cols, flds.shrinkage) || flds.check(minScale, maxScale, scales))
+            flds.createLevels(image.rows, image.cols);
+        flds.preprocess(image, s);
     }
     else
     {
         if (s)
-            s.enqueueCopy(colored, flds.hogluv);
+            s.enqueueCopy(image, flds.hogluv);
         else
-            colored.copyTo(flds.hogluv);
+            image.copyTo(flds.hogluv);
     }
 
     flds.detect(rois, objects, s);
@@ -587,10 +593,10 @@ void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& strea
     int shr = (*fields).shrinkage;
 
     const GpuMat roi = _roi.getGpuMat();
-    _mask.create( roi.cols / shr, roi.rows / shr, roi.type() );
+    _mask.create( roi.cols / shr, roi.rows / shr, roi.type());
     GpuMat mask = _mask.getGpuMat();
-    cv::gpu::GpuMat tmp;
 
+    GpuMat& tmp =  (*fields).genRoiTmp;
     cv::gpu::resize(roi, tmp, cv::Size(), 1.f / shr, 1.f / shr, CV_INTER_AREA, stream);
     cv::gpu::transpose(tmp, mask, stream);
 }
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 40bf5a0d6..266a7d400 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -234,7 +234,7 @@ GPU_TEST_P(SCascadeTestAll, detect,
         + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
     ASSERT_FALSE(coloredCpu.empty());
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+    GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
     rois.setTo(0);
     GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
     sub.setTo(cv::Scalar::all(1));

From 2eebd8d939f27e96829c0e8d229a74072ed8ad59 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 29 Nov 2012 18:40:27 +0400
Subject: [PATCH 109/155] fixed build under windows

---
 modules/gpu/src/icf.hpp         |  6 +++---
 modules/gpu/src/softcascade.cpp | 12 ++++++------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 295255f57..3f3449bad 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -88,11 +88,11 @@ struct __align__(8) Node
 {
     uchar4 rect;
     // ushort channel;
-    uint threshold;
+    unsigned int threshold;
 
     enum { THRESHOLD_MASK = 0x0FFFFFFF };
 
-    Node(const uchar4 r, const uint ch, const uint t) : rect(r), threshold(t + (ch << 28)) {}
+    Node(const uchar4 r, const unsigned int ch, const unsigned int t) : rect(r), threshold(t + (ch << 28)) {}
 };
 
 struct __align__(16) Detection
@@ -144,7 +144,7 @@ struct CascadeInvoker
         const int downscales, const cudaStream_t& stream = 0) const;
 
     template<bool isUp>
-    __device void detect(Detection* objects, const uint ndetections, uint* ctr, const int downscales) const;
+    __device void detect(Detection* objects, const unsigned int ndetections, unsigned int* ctr, const int downscales) const;
 };
 
 }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 1ccfa3a9d..431eeba0e 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -64,8 +64,8 @@ void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale, const int w, const int h)
 :  octave(idx), step(oct.stages), relScale(scale / oct.scale)
 {
-    workRect.x = round(w / (float)oct.shrinkage);
-    workRect.y = round(h / (float)oct.shrinkage);
+    workRect.x = cvRound(w / (float)oct.shrinkage);
+    workRect.y = cvRound(h / (float)oct.shrinkage);
 
     objSize.x  = cv::saturate_cast<uchar>(oct.size.x * relScale);
     objSize.y  = cv::saturate_cast<uchar>(oct.size.y * relScale);
@@ -75,7 +75,7 @@ cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale
         scaling[0] = scaling[1] = 1.f;
     else
     {
-        scaling[0] = (relScale < 1.f) ? 0.89f * ::pow(relScale, 1.099f / ::log(2)) : 1.f;
+        scaling[0] = (relScale < 1.f) ? 0.89f * ::pow(relScale, 1.099f / ::log(2.0f)) : 1.f;
         scaling[1] = relScale * relScale;
     }
 }
@@ -199,7 +199,7 @@ struct cv::gpu::SCascade::Fields
                         // int feature = (int)(*(inIt +=2)) + feature_offset;
                         inIt +=3;
                         // extract feature, Todo:check it
-                        uint th = saturate_cast<uint>((float)(*(inIt++)));
+                        unsigned int th = saturate_cast<unsigned int>((float)(*(inIt++)));
                         cv::FileNode ftn = (*ftrs)[SC_F_RECT];
                         cv::FileNodeIterator r_it = ftn.begin();
                         uchar4 rect;
@@ -214,7 +214,7 @@ struct cv::gpu::SCascade::Fields
                             rect.w -= rect.y;
                         }
 
-                        uint channel = saturate_cast<uint>((int)(*ftrs)[SC_F_CHANNEL]);
+                        unsigned int channel = saturate_cast<unsigned int>((int)(*ftrs)[SC_F_CHANNEL]);
                         vnodes.push_back(Node(rect, channel, th));
                         ++ftrs;
                     }
@@ -426,7 +426,7 @@ private:
         GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
         GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
 
-        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2))), nmag, 1, -1, s);
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2.0f))), nmag, 1, -1, s);
         cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang, 1, -1, s);
 
         //create uchar magnitude

From 08fbf667f949ee2ed1a23d9715a4718853cfe275 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 30 Nov 2012 17:35:28 +0400
Subject: [PATCH 110/155] refactored opengl functionality

* removed OpenGLFuncTab, now extensions are loaded internally
* renamed GlTexture -> GlTexture2D
* added support of GlBuffer and GlTexture2D to InputArray/OutputArray
* added ELEMENT_ARRAY_BUFFER and PIXEL_PACK_BUFFER targets
* added copyFrom/copyTo method for GlBuffer and GlTexture2D
* removed GlFont
* removed pointCloudShow
* removed OpenGLCleanCallback
---
 modules/core/include/opencv2/core/core.hpp    |   14 +-
 .../core/include/opencv2/core/internal.hpp    |   35 -
 .../include/opencv2/core/opengl_interop.hpp   |  288 +-
 modules/core/src/gl_core_3_1.cpp              | 2780 +++++++++++++++++
 modules/core/src/gl_core_3_1.hpp              | 1342 ++++++++
 modules/core/src/matrix.cpp                   |   65 +-
 modules/core/src/opengl_interop.cpp           | 1976 ++++++------
 modules/gpu/test/test_opengl.cpp              |  625 ++++
 modules/gpu/test/test_precomp.hpp             |    1 +
 .../include/opencv2/highgui/highgui.hpp       |    5 +-
 modules/highgui/src/precomp.hpp               |    3 -
 modules/highgui/src/window.cpp                |  247 +-
 modules/highgui/src/window_QT.cpp             |  305 --
 modules/highgui/src/window_QT.h               |   10 -
 modules/highgui/src/window_gtk.cpp            |  308 --
 modules/highgui/src/window_w32.cpp            |  315 --
 samples/cpp/point_cloud.cpp                   |  357 ---
 samples/gpu/brox_optical_flow.cpp             |   45 -
 samples/gpu/highgui_gpu.cpp                   |  135 -
 samples/gpu/opengl.cpp                        |  128 +
 samples/gpu/pyrlk_optical_flow.cpp            |   56 -
 samples/gpu/stereo_multi.cpp                  |    2 +-
 22 files changed, 6062 insertions(+), 2980 deletions(-)
 create mode 100644 modules/core/src/gl_core_3_1.cpp
 create mode 100644 modules/core/src/gl_core_3_1.hpp
 create mode 100644 modules/gpu/test/test_opengl.cpp
 delete mode 100644 samples/cpp/point_cloud.cpp
 delete mode 100644 samples/gpu/highgui_gpu.cpp
 create mode 100644 samples/gpu/opengl.cpp

diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp
index 60d9d013c..68a9689da 100644
--- a/modules/core/include/opencv2/core/core.hpp
+++ b/modules/core/include/opencv2/core/core.hpp
@@ -91,7 +91,7 @@ class SparseMat;
 typedef Mat MatND;
 
 class GlBuffer;
-class GlTexture;
+class GlTexture2D;
 class GlArrays;
 class GlCamera;
 
@@ -1311,7 +1311,7 @@ public:
         STD_VECTOR_MAT    = 5 << KIND_SHIFT,
         EXPR              = 6 << KIND_SHIFT,
         OPENGL_BUFFER     = 7 << KIND_SHIFT,
-        OPENGL_TEXTURE    = 8 << KIND_SHIFT,
+        OPENGL_TEXTURE2D    = 8 << KIND_SHIFT,
         GPU_MAT           = 9 << KIND_SHIFT
     };
     _InputArray();
@@ -1328,13 +1328,13 @@ public:
     _InputArray(const Scalar& s);
     _InputArray(const double& val);
     _InputArray(const GlBuffer& buf);
-    _InputArray(const GlTexture& tex);
+    _InputArray(const GlTexture2D& tex);
     _InputArray(const gpu::GpuMat& d_mat);
 
     virtual Mat getMat(int i=-1) const;
     virtual void getMatVector(vector<Mat>& mv) const;
     virtual GlBuffer getGlBuffer() const;
-    virtual GlTexture getGlTexture() const;
+    virtual GlTexture2D getGlTexture2D() const;
     virtual gpu::GpuMat getGpuMat() const;
 
     virtual int kind() const;
@@ -1385,6 +1385,8 @@ public:
     template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(_Tp* vec, int n);
     _OutputArray(gpu::GpuMat& d_mat);
+    _OutputArray(GlBuffer& buf);
+    _OutputArray(GlTexture2D& tex);
 
     _OutputArray(const Mat& m);
     template<typename _Tp> _OutputArray(const vector<_Tp>& vec);
@@ -1395,12 +1397,16 @@ public:
     template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(const _Tp* vec, int n);
     _OutputArray(const gpu::GpuMat& d_mat);
+    _OutputArray(const GlBuffer& buf);
+    _OutputArray(const GlTexture2D& tex);
 
     virtual bool fixedSize() const;
     virtual bool fixedType() const;
     virtual bool needed() const;
     virtual Mat& getMatRef(int i=-1) const;
     virtual gpu::GpuMat& getGpuMatRef() const;
+    virtual GlBuffer& getGlBufferRef() const;
+    virtual GlTexture2D& getGlTexture2DRef() const;
     virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
     virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
     virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const;
diff --git a/modules/core/include/opencv2/core/internal.hpp b/modules/core/include/opencv2/core/internal.hpp
index 93e56c3ab..c042ccaf1 100644
--- a/modules/core/include/opencv2/core/internal.hpp
+++ b/modules/core/include/opencv2/core/internal.hpp
@@ -750,39 +750,4 @@ typedef struct CvBigFuncTable
     (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG;  \
     (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG
 
-#ifdef __cplusplus
-//! OpenGL extension table
-class CV_EXPORTS CvOpenGlFuncTab
-{
-public:
-    virtual ~CvOpenGlFuncTab();
-
-    virtual void genBuffers(int n, unsigned int* buffers) const = 0;
-    virtual void deleteBuffers(int n, const unsigned int* buffers) const = 0;
-
-    virtual void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const = 0;
-    virtual void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const = 0;
-
-    virtual void bindBuffer(unsigned int target, unsigned int buffer) const = 0;
-
-    virtual void* mapBuffer(unsigned int target, unsigned int access) const = 0;
-    virtual void unmapBuffer(unsigned int target) const = 0;
-
-    virtual void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const = 0;
-
-    virtual bool isGlContextInitialized() const = 0;
-};
-
-CV_EXPORTS void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab);
-
-CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* func = "");
-
-#if defined(__GNUC__)
-    #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__, __func__)) )
-#else
-    #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__)) )
-#endif
-
-#endif //__cplusplus
-
 #endif // __OPENCV_CORE_INTERNAL_HPP__
diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp
index 0bd2e9fdc..91fba7b7f 100644
--- a/modules/core/include/opencv2/core/opengl_interop.hpp
+++ b/modules/core/include/opencv2/core/opengl_interop.hpp
@@ -47,40 +47,68 @@
 
 #include "opencv2/core/core.hpp"
 
-namespace cv
-{
+namespace cv {
+
+CV_EXPORTS bool checkGlError(const char* file, const int line, const char* func = "");
+
+#if defined(__GNUC__)
+    #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__, __func__)) )
+#else
+    #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__)) )
+#endif
+
+/////////////////// OpenGL Objects ///////////////////
+
 //! Smart pointer for OpenGL buffer memory with reference counting.
 class CV_EXPORTS GlBuffer
 {
 public:
-    enum Usage
+    enum Target
     {
-        ARRAY_BUFFER = 0x8892,  // buffer will use for OpenGL arrays (vertices, colors, normals, etc)
-        TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures
+        ARRAY_BUFFER         = 0x8892, //!< The buffer will be used as a source for vertex data
+        ELEMENT_ARRAY_BUFFER = 0x8893, //!< The buffer will be used for indices (in glDrawElements, for example)
+        PIXEL_PACK_BUFFER    = 0x88EB, //!< The buffer will be used for reading from OpenGL textures
+        PIXEL_UNPACK_BUFFER  = 0x88EC  //!< The buffer will be used for writing to OpenGL textures
     };
 
     //! create empty buffer
-    explicit GlBuffer(Usage usage);
+    GlBuffer();
+
+    //! create buffer from existed buffer id
+    GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false);
+    GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false);
 
     //! create buffer
-    GlBuffer(int rows, int cols, int type, Usage usage);
-    GlBuffer(Size size, int type, Usage usage);
+    GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER);
+    GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER);
 
     //! copy from host/device memory
-    GlBuffer(InputArray mat, Usage usage);
+    explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER);
 
-    void create(int rows, int cols, int type, Usage usage);
-    void create(Size size, int type, Usage usage);
-    void create(int rows, int cols, int type);
-    void create(Size size, int type);
+    //! create buffer
+    void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER);
+    void create(Size asize, int atype, Target target = ARRAY_BUFFER) { create(asize.height, asize.width, atype, target); }
 
+    //! release memory and delete buffer object
     void release();
 
-    //! copy from host/device memory
-    void copyFrom(InputArray mat);
+    //! set auto release mode (if true, release will be called in object's destructor)
+    void setAutoRelease(bool flag);
 
-    void bind() const;
-    void unbind() const;
+    //! copy from host/device memory
+    void copyFrom(InputArray arr, Target target = ARRAY_BUFFER);
+
+    //! copy to host/device memory
+    void copyTo(OutputArray arr, Target target = ARRAY_BUFFER) const;
+
+    //! create copy of current buffer
+    GlBuffer clone(Target target = ARRAY_BUFFER) const;
+
+    //! bind buffer for specified target
+    void bind(Target target) const;
+
+    //! unbind any buffers from specified target
+    static void unbind(Target target);
 
     //! map to host memory
     Mat mapHost();
@@ -90,162 +118,134 @@ public:
     gpu::GpuMat mapDevice();
     void unmapDevice();
 
-    inline int rows() const { return rows_; }
-    inline int cols() const { return cols_; }
-    inline Size size() const { return Size(cols_, rows_); }
-    inline bool empty() const { return rows_ == 0 || cols_ == 0; }
+    int rows() const { return rows_; }
+    int cols() const { return cols_; }
+    Size size() const { return Size(cols_, rows_); }
+    bool empty() const { return rows_ == 0 || cols_ == 0; }
 
-    inline int type() const { return type_; }
-    inline int depth() const { return CV_MAT_DEPTH(type_); }
-    inline int channels() const { return CV_MAT_CN(type_); }
-    inline int elemSize() const { return CV_ELEM_SIZE(type_); }
-    inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
+    int type() const { return type_; }
+    int depth() const { return CV_MAT_DEPTH(type_); }
+    int channels() const { return CV_MAT_CN(type_); }
+    int elemSize() const { return CV_ELEM_SIZE(type_); }
+    int elemSize1() const { return CV_ELEM_SIZE1(type_); }
 
-    inline Usage usage() const { return usage_; }
+    unsigned int bufId() const;
 
     class Impl;
+
 private:
+    Ptr<Impl> impl_;
     int rows_;
     int cols_;
     int type_;
-    Usage usage_;
-
-    Ptr<Impl> impl_;
 };
 
 template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::delete_obj();
 
-//! Smart pointer for OpenGL 2d texture memory with reference counting.
-class CV_EXPORTS GlTexture
+//! Smart pointer for OpenGL 2D texture memory with reference counting.
+class CV_EXPORTS GlTexture2D
 {
 public:
+    enum Format
+    {
+        NONE            = 0,
+        DEPTH_COMPONENT = 0x1902, //!< Depth
+        RGB             = 0x1907, //!< Red, Green, Blue
+        RGBA            = 0x1908  //!< Red, Green, Blue, Alpha
+    };
+
     //! create empty texture
-    GlTexture();
+    GlTexture2D();
+
+    //! create texture from existed texture id
+    GlTexture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false);
+    GlTexture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false);
 
     //! create texture
-    GlTexture(int rows, int cols, int type);
-    GlTexture(Size size, int type);
+    GlTexture2D(int arows, int acols, Format aformat);
+    GlTexture2D(Size asize, Format aformat);
 
     //! copy from host/device memory
-    explicit GlTexture(InputArray mat, bool bgra = true);
+    explicit GlTexture2D(InputArray arr);
 
-    void create(int rows, int cols, int type);
-    void create(Size size, int type);
+    //! create texture
+    void create(int arows, int acols, Format aformat);
+    void create(Size asize, Format aformat) { create(asize.height, asize.width, aformat); }
+
+    //! release memory and delete texture object
     void release();
 
+    //! set auto release mode (if true, release will be called in object's destructor)
+    void setAutoRelease(bool flag);
+
     //! copy from host/device memory
-    void copyFrom(InputArray mat, bool bgra = true);
+    void copyFrom(InputArray arr);
 
+    //! copy to host/device memory
+    void copyTo(OutputArray arr, int ddepth = CV_32F) const;
+
+    //! bind texture to current active texture unit for GL_TEXTURE_2D target
     void bind() const;
-    void unbind() const;
 
-    inline int rows() const { return rows_; }
-    inline int cols() const { return cols_; }
-    inline Size size() const { return Size(cols_, rows_); }
-    inline bool empty() const { return rows_ == 0 || cols_ == 0; }
+    int rows() const { return rows_; }
+    int cols() const { return cols_; }
+    Size size() const { return Size(cols_, rows_); }
+    bool empty() const { return rows_ == 0 || cols_ == 0; }
 
-    inline int type() const { return type_; }
-    inline int depth() const { return CV_MAT_DEPTH(type_); }
-    inline int channels() const { return CV_MAT_CN(type_); }
-    inline int elemSize() const { return CV_ELEM_SIZE(type_); }
-    inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
+    Format format() const { return format_; }
+
+    unsigned int texId() const;
 
     class Impl;
+
 private:
+    Ptr<Impl> impl_;
     int rows_;
     int cols_;
-    int type_;
-
-    Ptr<Impl> impl_;
-    GlBuffer buf_;
+    Format format_;
 };
 
-template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj();
+template <> CV_EXPORTS void Ptr<GlTexture2D::Impl>::delete_obj();
 
 //! OpenGL Arrays
 class CV_EXPORTS GlArrays
 {
 public:
-    inline GlArrays()
-        : vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER)
-    {
-    }
+    GlArrays();
 
     void setVertexArray(InputArray vertex);
-    inline void resetVertexArray() { vertex_.release(); }
+    void resetVertexArray();
 
-    void setColorArray(InputArray color, bool bgra = true);
-    inline void resetColorArray() { color_.release(); }
+    void setColorArray(InputArray color);
+    void resetColorArray();
 
     void setNormalArray(InputArray normal);
-    inline void resetNormalArray() { normal_.release(); }
+    void resetNormalArray();
 
     void setTexCoordArray(InputArray texCoord);
-    inline void resetTexCoordArray() { texCoord_.release(); }
+    void resetTexCoordArray();
+
+    void release();
+
+    void setAutoRelease(bool flag);
 
     void bind() const;
-    void unbind() const;
 
-    inline int rows() const { return vertex_.rows(); }
-    inline int cols() const { return vertex_.cols(); }
-    inline Size size() const { return vertex_.size(); }
-    inline bool empty() const { return vertex_.empty(); }
+    int size() const { return size_; }
+    bool empty() const { return size_ == 0; }
 
 private:
+    int size_;
     GlBuffer vertex_;
     GlBuffer color_;
-    bool bgra_;
     GlBuffer normal_;
     GlBuffer texCoord_;
 };
 
-//! OpenGL Font
-class CV_EXPORTS GlFont
-{
-public:
-    enum Weight
-    {
-        WEIGHT_LIGHT    = 300,
-        WEIGHT_NORMAL   = 400,
-        WEIGHT_SEMIBOLD = 600,
-        WEIGHT_BOLD     = 700,
-        WEIGHT_BLACK    = 900
-    };
-
-    enum Style
-    {
-        STYLE_NORMAL    = 0,
-        STYLE_ITALIC    = 1,
-        STYLE_UNDERLINE = 2
-    };
-
-    static Ptr<GlFont> get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL);
-
-    void draw(const char* str, size_t len) const;
-
-    inline const std::string& family() const { return family_; }
-    inline int height() const { return height_; }
-    inline Weight weight() const { return weight_; }
-    inline Style style() const { return style_; }
-
-private:
-    GlFont(const std::string& family, int height, Weight weight, Style style);
-
-    std::string family_;
-    int height_;
-    Weight weight_;
-    Style style_;
-
-    unsigned int base_;
-
-    GlFont(const GlFont&);
-    GlFont& operator =(const GlFont&);
-};
-
-//! render functions
+/////////////////// Render Functions ///////////////////
 
 //! render texture rectangle in window
-CV_EXPORTS void render(const GlTexture& tex,
+CV_EXPORTS void render(const GlTexture2D& tex,
     Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
     Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0));
 
@@ -267,67 +267,13 @@ namespace RenderMode {
 
 //! render OpenGL arrays
 CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255));
+CV_EXPORTS void render(const GlArrays& arr, InputArray indices, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255));
 
-CV_EXPORTS void render(const std::string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos);
-
-//! OpenGL camera
-class CV_EXPORTS GlCamera
-{
-public:
-    GlCamera();
-
-    void lookAt(Point3d eye, Point3d center, Point3d up);
-    void setCameraPos(Point3d pos, double yaw, double pitch, double roll);
-
-    void setScale(Point3d scale);
-
-    void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true);
-    void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar);
-    void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar);
-
-    void setupProjectionMatrix() const;
-    void setupModelViewMatrix() const;
-
-private:
-    Point3d eye_;
-    Point3d center_;
-    Point3d up_;
-
-    Point3d pos_;
-    double yaw_;
-    double pitch_;
-    double roll_;
-
-    bool useLookAtParams_;
-
-    Point3d scale_;
-
-    Mat projectionMatrix_;
-
-    double fov_;
-    double aspect_;
-
-    double left_;
-    double right_;
-    double bottom_;
-    double top_;
-
-    double zNear_;
-    double zFar_;
-
-    bool perspectiveProjection_;
-};
-
-inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); }
-inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); }
-inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); }
-inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); }
-
-namespace gpu
-{
+namespace gpu {
     //! set a CUDA device to use OpenGL interoperability
     CV_EXPORTS void setGlDevice(int device = 0);
 }
+
 } // namespace cv
 
 #endif // __cplusplus
diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp
new file mode 100644
index 000000000..9e4865efb
--- /dev/null
+++ b/modules/core/src/gl_core_3_1.cpp
@@ -0,0 +1,2780 @@
+#include "cvconfig.h"
+
+#ifdef HAVE_OPENGL
+
+#include <algorithm>
+#include <string.h>
+#include "gl_core_3_1.hpp"
+
+#if defined(__APPLE__)
+#include <mach-o/dyld.h>
+
+static void* AppleGLGetProcAddress (const GLubyte *name)
+{
+  static const struct mach_header* image = NULL;
+  NSSymbol symbol;
+  char* symbolName;
+  if (NULL == image)
+  {
+    image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
+  }
+  /* prepend a '_' for the Unix C symbol mangling convention */
+  symbolName = malloc(strlen((const char*)name) + 2);
+  strcpy(symbolName+1, (const char*)name);
+  symbolName[0] = '_';
+  symbol = NULL;
+  /* if (NSIsSymbolNameDefined(symbolName))
+     symbol = NSLookupAndBindSymbol(symbolName); */
+  symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;
+  free(symbolName);
+  return symbol ? NSAddressOfSymbol(symbol) : NULL;
+}
+#endif /* __APPLE__ */
+
+#if defined(__sgi) || defined (__sun)
+#include <dlfcn.h>
+#include <stdio.h>
+
+static void* SunGetProcAddress (const GLubyte* name)
+{
+  static void* h = NULL;
+  static void* gpa;
+
+  if (h == NULL)
+  {
+    if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
+    gpa = dlsym(h, "glXGetProcAddress");
+  }
+
+  if (gpa != NULL)
+    return ((void*(*)(const GLubyte*))gpa)(name);
+  else
+    return dlsym(h, (const char*)name);
+}
+#endif /* __sgi || __sun */
+
+#if defined(_WIN32)
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4055)
+#pragma warning(disable: 4054)
+#endif
+
+static int TestPointer(const PROC pTest)
+{
+    ptrdiff_t iTest;
+    if(!pTest) return 0;
+    iTest = (ptrdiff_t)pTest;
+
+    if(iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) return 0;
+
+    return 1;
+}
+
+static PROC WinGetProcAddress(const char *name)
+{
+    HMODULE glMod = NULL;
+    PROC pFunc = wglGetProcAddress((LPCSTR)name);
+    if(TestPointer(pFunc))
+    {
+        return pFunc;
+    }
+    glMod = GetModuleHandleA("OpenGL32.dll");
+    return (PROC)GetProcAddress(glMod, (LPCSTR)name);
+}
+
+#define IntGetProcAddress(name) WinGetProcAddress(name)
+#else
+    #if defined(__APPLE__)
+        #define IntGetProcAddress(name) AppleGLGetProcAddress(name)
+    #else
+        #if defined(__sgi) || defined(__sun)
+            #define IntGetProcAddress(name) SunGetProcAddress(name)
+        #else /* GLX */
+            #include <GL/glx.h>
+
+            #define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
+        #endif
+    #endif
+#endif
+
+namespace gl
+{
+  namespace exts
+  {
+  }
+
+  // Extension: 1.1
+  typedef void (CODEGEN_FUNCPTR *PFNCULLFACEPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNFRONTFACEPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNHINTPROC)(GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNLINEWIDTHPROC)(GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNPOINTSIZEPROC)(GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNPOLYGONMODEPROC)(GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNSCISSORPROC)(GLint , GLint , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIPROC)(GLenum , GLenum , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARPROC)(GLbitfield );
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARSTENCILPROC)(GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARDEPTHPROC)(GLdouble );
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean );
+  typedef void (CODEGEN_FUNCPTR *PFNDEPTHMASKPROC)(GLboolean );
+  typedef void (CODEGEN_FUNCPTR *PFNDISABLEPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNENABLEPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNFINISHPROC)();
+  typedef void (CODEGEN_FUNCPTR *PFNFLUSHPROC)();
+  typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCPROC)(GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNLOGICOPPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCPROC)(GLenum , GLint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPPROC)(GLenum , GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNDEPTHFUNCPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREFPROC)(GLenum , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREIPROC)(GLenum , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNREADBUFFERPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANVPROC)(GLenum , GLboolean *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETDOUBLEVPROC)(GLenum , GLdouble *);
+  typedef GLenum (CODEGEN_FUNCPTR *PFNGETERRORPROC)();
+  typedef void (CODEGEN_FUNCPTR *PFNGETFLOATVPROC)(GLenum , GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERVPROC)(GLenum , GLint *);
+  typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNDEPTHRANGEPROC)(GLdouble , GLdouble );
+  typedef void (CODEGEN_FUNCPTR *PFNVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSPROC)(GLenum , GLint , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETPOINTERVPROC)(GLenum , GLvoid* *);
+  typedef void (CODEGEN_FUNCPTR *PFNPOLYGONOFFSETPROC)(GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNBINDTEXTUREPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETETEXTURESPROC)(GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENTEXTURESPROC)(GLsizei , GLuint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISTEXTUREPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNINDEXUBPROC)(GLubyte );
+  typedef void (CODEGEN_FUNCPTR *PFNINDEXUBVPROC)(const GLubyte *);
+
+  // Extension: 1.2
+  typedef void (CODEGEN_FUNCPTR *PFNBLENDCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWRANGEELEMENTSPROC)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+
+  // Extension: 1.3
+  typedef void (CODEGEN_FUNCPTR *PFNACTIVETEXTUREPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNSAMPLECOVERAGEPROC)(GLfloat , GLboolean );
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE3DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETCOMPRESSEDTEXIMAGEPROC)(GLenum , GLint , GLvoid *);
+
+  // Extension: 1.4
+  typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWARRAYSPROC)(GLenum , const GLint *, const GLsizei *, GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWELEMENTSPROC)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFPROC)(GLenum , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFVPROC)(GLenum , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIPROC)(GLenum , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIVPROC)(GLenum , const GLint *);
+
+  // Extension: 1.5
+  typedef void (CODEGEN_FUNCPTR *PFNGENQUERIESPROC)(GLsizei , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNDELETEQUERIESPROC)(GLsizei , const GLuint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISQUERYPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBEGINQUERYPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNENDQUERYPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYIVPROC)(GLenum , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTIVPROC)(GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTUIVPROC)(GLuint , GLenum , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETEBUFFERSPROC)(GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENBUFFERSPROC)(GLsizei , GLuint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISBUFFERPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBUFFERDATAPROC)(GLenum , GLsizeiptr , const GLvoid *, GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , GLvoid *);
+  typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERPROC)(GLenum , GLenum );
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNUNMAPBUFFERPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPOINTERVPROC)(GLenum , GLenum , GLvoid* *);
+
+  // Extension: 2.0
+  typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONSEPARATEPROC)(GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERSPROC)(GLsizei , const GLenum *);
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCSEPARATEPROC)(GLenum , GLenum , GLint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKSEPARATEPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNATTACHSHADERPROC)(GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBINDATTRIBLOCATIONPROC)(GLuint , GLuint , const GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNCOMPILESHADERPROC)(GLuint );
+  typedef GLuint (CODEGEN_FUNCPTR *PFNCREATEPROGRAMPROC)();
+  typedef GLuint (CODEGEN_FUNCPTR *PFNCREATESHADERPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETEPROGRAMPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETESHADERPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDETACHSHADERPROC)(GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDISABLEVERTEXATTRIBARRAYPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNENABLEVERTEXATTRIBARRAYPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEATTRIBPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETATTACHEDSHADERSPROC)(GLuint , GLsizei , GLsizei *, GLuint *);
+  typedef GLint (CODEGEN_FUNCPTR *PFNGETATTRIBLOCATIONPROC)(GLuint , const GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMIVPROC)(GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERIVPROC)(GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERSOURCEPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+  typedef GLint (CODEGEN_FUNCPTR *PFNGETUNIFORMLOCATIONPROC)(GLuint , const GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMFVPROC)(GLuint , GLint , GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMIVPROC)(GLuint , GLint , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBDVPROC)(GLuint , GLenum , GLdouble *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBFVPROC)(GLuint , GLenum , GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIVPROC)(GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBPOINTERVPROC)(GLuint , GLenum , GLvoid* *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISPROGRAMPROC)(GLuint );
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISSHADERPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNLINKPROGRAMPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNSHADERSOURCEPROC)(GLuint , GLsizei , const GLchar* const *, const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUSEPROGRAMPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FPROC)(GLint , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FPROC)(GLint , GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FPROC)(GLint , GLfloat , GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FPROC)(GLint , GLfloat , GLfloat , GLfloat , GLfloat );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IPROC)(GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IPROC)(GLint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IPROC)(GLint , GLint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IPROC)(GLint , GLint , GLint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FVPROC)(GLint , GLsizei , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FVPROC)(GLint , GLsizei , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FVPROC)(GLint , GLsizei , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FVPROC)(GLint , GLsizei , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IVPROC)(GLint , GLsizei , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IVPROC)(GLint , GLsizei , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IVPROC)(GLint , GLsizei , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IVPROC)(GLint , GLsizei , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNVALIDATEPROGRAMPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBPOINTERPROC)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *);
+
+  // Extension: 2.1
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+
+  // Extension: ARB_vertex_array_object
+  typedef void (CODEGEN_FUNCPTR *PFNBINDVERTEXARRAYPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETEVERTEXARRAYSPROC)(GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENVERTEXARRAYSPROC)(GLsizei , GLuint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISVERTEXARRAYPROC)(GLuint );
+
+  // Extension: ARB_map_buffer_range
+  typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr , GLbitfield );
+  typedef void (CODEGEN_FUNCPTR *PFNFLUSHMAPPEDBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr );
+
+  // Extension: ARB_framebuffer_object
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISRENDERBUFFERPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBINDRENDERBUFFERPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETERENDERBUFFERSPROC)(GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENRENDERBUFFERSPROC)(GLsizei , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEPROC)(GLenum , GLenum , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNGETRENDERBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISFRAMEBUFFERPROC)(GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBINDFRAMEBUFFERPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDELETEFRAMEBUFFERSPROC)(GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENFRAMEBUFFERSPROC)(GLsizei , GLuint *);
+  typedef GLenum (CODEGEN_FUNCPTR *PFNCHECKFRAMEBUFFERSTATUSPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE1DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE2DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE3DPROC)(GLenum , GLenum , GLenum , GLuint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERRENDERBUFFERPROC)(GLenum , GLenum , GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum , GLenum , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGENERATEMIPMAPPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNBLITFRAMEBUFFERPROC)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum , GLsizei , GLenum , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURELAYERPROC)(GLenum , GLenum , GLuint , GLint , GLint );
+
+  // Extension: 3.0
+  typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKIPROC)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean );
+  typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANI_VPROC)(GLenum , GLuint , GLboolean *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERI_VPROC)(GLenum , GLuint , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNENABLEIPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNDISABLEIPROC)(GLenum , GLuint );
+  typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDIPROC)(GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNBEGINTRANSFORMFEEDBACKPROC)(GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNENDTRANSFORMFEEDBACKPROC)();
+  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERRANGEPROC)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr );
+  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERBASEPROC)(GLenum , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNTRANSFORMFEEDBACKVARYINGSPROC)(GLuint , GLsizei , const GLchar* const *, GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNCLAMPCOLORPROC)(GLenum , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNBEGINCONDITIONALRENDERPROC)(GLuint , GLenum );
+  typedef void (CODEGEN_FUNCPTR *PFNENDCONDITIONALRENDERPROC)();
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBIPOINTERPROC)(GLuint , GLint , GLenum , GLsizei , const GLvoid *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIIVPROC)(GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIUIVPROC)(GLuint , GLenum , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IPROC)(GLuint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IPROC)(GLuint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IPROC)(GLuint , GLint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IPROC)(GLuint , GLint , GLint , GLint , GLint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIPROC)(GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIPROC)(GLuint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIPROC)(GLuint , GLuint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIPROC)(GLuint , GLuint , GLuint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IVPROC)(GLuint , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IVPROC)(GLuint , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IVPROC)(GLuint , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IVPROC)(GLuint , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIVPROC)(GLuint , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIVPROC)(GLuint , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIVPROC)(GLuint , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIVPROC)(GLuint , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4BVPROC)(GLuint , const GLbyte *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4SVPROC)(GLuint , const GLshort *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UBVPROC)(GLuint , const GLubyte *);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4USVPROC)(GLuint , const GLushort *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMUIVPROC)(GLuint , GLint , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNBINDFRAGDATALOCATIONPROC)(GLuint , GLuint , const GLchar *);
+  typedef GLint (CODEGEN_FUNCPTR *PFNGETFRAGDATALOCATIONPROC)(GLuint , const GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIPROC)(GLint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIPROC)(GLint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIPROC)(GLint , GLuint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIPROC)(GLint , GLuint , GLuint , GLuint , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIVPROC)(GLint , GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIVPROC)(GLint , GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIVPROC)(GLint , GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIVPROC)(GLint , GLsizei , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIIVPROC)(GLenum , GLenum , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIUIVPROC)(GLenum , GLenum , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIIVPROC)(GLenum , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIUIVPROC)(GLenum , GLenum , GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERIVPROC)(GLenum , GLint , const GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERUIVPROC)(GLenum , GLint , const GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFVPROC)(GLenum , GLint , const GLfloat *);
+  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFIPROC)(GLenum , GLint , GLfloat , GLint );
+  typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGIPROC)(GLenum , GLuint );
+
+  // Extension: ARB_uniform_buffer_object
+  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMINDICESPROC)(GLuint , GLsizei , const GLchar* const *, GLuint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMSIVPROC)(GLuint , GLsizei , const GLuint *, GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
+  typedef GLuint (CODEGEN_FUNCPTR *PFNGETUNIFORMBLOCKINDEXPROC)(GLuint , const GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKIVPROC)(GLuint , GLuint , GLenum , GLint *);
+  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
+  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMBLOCKBINDINGPROC)(GLuint , GLuint , GLuint );
+
+  // Extension: ARB_copy_buffer
+  typedef void (CODEGEN_FUNCPTR *PFNCOPYBUFFERSUBDATAPROC)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr );
+
+  // Extension: 3.1
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSINSTANCEDPROC)(GLenum , GLint , GLsizei , GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSINSTANCEDPROC)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei );
+  typedef void (CODEGEN_FUNCPTR *PFNTEXBUFFERPROC)(GLenum , GLenum , GLuint );
+  typedef void (CODEGEN_FUNCPTR *PFNPRIMITIVERESTARTINDEXPROC)(GLuint );
+
+  // Legacy
+  typedef void (CODEGEN_FUNCPTR *PFNENABLECLIENTSTATEPROC)(GLenum cap);
+  typedef void (CODEGEN_FUNCPTR *PFNDISABLECLIENTSTATEPROC)(GLenum cap);
+  typedef void (CODEGEN_FUNCPTR *PFNVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+  typedef void (CODEGEN_FUNCPTR *PFNNORMALPOINTERPROC)(GLenum type, GLsizei stride, const GLvoid *ptr);
+  typedef void (CODEGEN_FUNCPTR *PFNCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+  typedef void (CODEGEN_FUNCPTR *PFNTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+
+  typedef void (CODEGEN_FUNCPTR *PFNTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
+
+  typedef void (CODEGEN_FUNCPTR *PFNMATRIXMODEPROC)(GLenum modem);
+  typedef void (CODEGEN_FUNCPTR *PFNLOADIDENTITYPROC)(void);
+  typedef void (CODEGEN_FUNCPTR *PFNORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
+
+  typedef void (CODEGEN_FUNCPTR *PFNCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
+
+
+
+  // Extension: 1.1
+  PFNCULLFACEPROC CullFace;
+  PFNFRONTFACEPROC FrontFace;
+  PFNHINTPROC Hint;
+  PFNLINEWIDTHPROC LineWidth;
+  PFNPOINTSIZEPROC PointSize;
+  PFNPOLYGONMODEPROC PolygonMode;
+  PFNSCISSORPROC Scissor;
+  PFNTEXPARAMETERFPROC TexParameterf;
+  PFNTEXPARAMETERFVPROC TexParameterfv;
+  PFNTEXPARAMETERIPROC TexParameteri;
+  PFNTEXPARAMETERIVPROC TexParameteriv;
+  PFNTEXIMAGE1DPROC TexImage1D;
+  PFNTEXIMAGE2DPROC TexImage2D;
+  PFNDRAWBUFFERPROC DrawBuffer;
+  PFNCLEARPROC Clear;
+  PFNCLEARCOLORPROC ClearColor;
+  PFNCLEARSTENCILPROC ClearStencil;
+  PFNCLEARDEPTHPROC ClearDepth;
+  PFNSTENCILMASKPROC StencilMask;
+  PFNCOLORMASKPROC ColorMask;
+  PFNDEPTHMASKPROC DepthMask;
+  PFNDISABLEPROC Disable;
+  PFNENABLEPROC Enable;
+  PFNFINISHPROC Finish;
+  PFNFLUSHPROC Flush;
+  PFNBLENDFUNCPROC BlendFunc;
+  PFNLOGICOPPROC LogicOp;
+  PFNSTENCILFUNCPROC StencilFunc;
+  PFNSTENCILOPPROC StencilOp;
+  PFNDEPTHFUNCPROC DepthFunc;
+  PFNPIXELSTOREFPROC PixelStoref;
+  PFNPIXELSTOREIPROC PixelStorei;
+  PFNREADBUFFERPROC ReadBuffer;
+  PFNREADPIXELSPROC ReadPixels;
+  PFNGETBOOLEANVPROC GetBooleanv;
+  PFNGETDOUBLEVPROC GetDoublev;
+  PFNGETERRORPROC GetError;
+  PFNGETFLOATVPROC GetFloatv;
+  PFNGETINTEGERVPROC GetIntegerv;
+  PFNGETSTRINGPROC GetString;
+  PFNGETTEXIMAGEPROC GetTexImage;
+  PFNGETTEXPARAMETERFVPROC GetTexParameterfv;
+  PFNGETTEXPARAMETERIVPROC GetTexParameteriv;
+  PFNGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv;
+  PFNGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv;
+  PFNISENABLEDPROC IsEnabled;
+  PFNDEPTHRANGEPROC DepthRange;
+  PFNVIEWPORTPROC Viewport;
+  PFNDRAWARRAYSPROC DrawArrays;
+  PFNDRAWELEMENTSPROC DrawElements;
+  PFNGETPOINTERVPROC GetPointerv;
+  PFNPOLYGONOFFSETPROC PolygonOffset;
+  PFNCOPYTEXIMAGE1DPROC CopyTexImage1D;
+  PFNCOPYTEXIMAGE2DPROC CopyTexImage2D;
+  PFNCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D;
+  PFNCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
+  PFNTEXSUBIMAGE1DPROC TexSubImage1D;
+  PFNTEXSUBIMAGE2DPROC TexSubImage2D;
+  PFNBINDTEXTUREPROC BindTexture;
+  PFNDELETETEXTURESPROC DeleteTextures;
+  PFNGENTEXTURESPROC GenTextures;
+  PFNISTEXTUREPROC IsTexture;
+  PFNINDEXUBPROC Indexub;
+  PFNINDEXUBVPROC Indexubv;
+
+  // Extension: 1.2
+  PFNBLENDCOLORPROC BlendColor;
+  PFNBLENDEQUATIONPROC BlendEquation;
+  PFNDRAWRANGEELEMENTSPROC DrawRangeElements;
+  PFNTEXSUBIMAGE3DPROC TexSubImage3D;
+  PFNCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D;
+
+  // Extension: 1.3
+  PFNACTIVETEXTUREPROC ActiveTexture;
+  PFNSAMPLECOVERAGEPROC SampleCoverage;
+  PFNCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D;
+  PFNCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
+  PFNCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D;
+  PFNCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D;
+  PFNCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
+  PFNCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D;
+  PFNGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage;
+
+  // Extension: 1.4
+  PFNBLENDFUNCSEPARATEPROC BlendFuncSeparate;
+  PFNMULTIDRAWARRAYSPROC MultiDrawArrays;
+  PFNMULTIDRAWELEMENTSPROC MultiDrawElements;
+  PFNPOINTPARAMETERFPROC PointParameterf;
+  PFNPOINTPARAMETERFVPROC PointParameterfv;
+  PFNPOINTPARAMETERIPROC PointParameteri;
+  PFNPOINTPARAMETERIVPROC PointParameteriv;
+
+  // Extension: 1.5
+  PFNGENQUERIESPROC GenQueries;
+  PFNDELETEQUERIESPROC DeleteQueries;
+  PFNISQUERYPROC IsQuery;
+  PFNBEGINQUERYPROC BeginQuery;
+  PFNENDQUERYPROC EndQuery;
+  PFNGETQUERYIVPROC GetQueryiv;
+  PFNGETQUERYOBJECTIVPROC GetQueryObjectiv;
+  PFNGETQUERYOBJECTUIVPROC GetQueryObjectuiv;
+  PFNBINDBUFFERPROC BindBuffer;
+  PFNDELETEBUFFERSPROC DeleteBuffers;
+  PFNGENBUFFERSPROC GenBuffers;
+  PFNISBUFFERPROC IsBuffer;
+  PFNBUFFERDATAPROC BufferData;
+  PFNBUFFERSUBDATAPROC BufferSubData;
+  PFNGETBUFFERSUBDATAPROC GetBufferSubData;
+  PFNMAPBUFFERPROC MapBuffer;
+  PFNUNMAPBUFFERPROC UnmapBuffer;
+  PFNGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
+  PFNGETBUFFERPOINTERVPROC GetBufferPointerv;
+
+  // Extension: 2.0
+  PFNBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
+  PFNDRAWBUFFERSPROC DrawBuffers;
+  PFNSTENCILOPSEPARATEPROC StencilOpSeparate;
+  PFNSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
+  PFNSTENCILMASKSEPARATEPROC StencilMaskSeparate;
+  PFNATTACHSHADERPROC AttachShader;
+  PFNBINDATTRIBLOCATIONPROC BindAttribLocation;
+  PFNCOMPILESHADERPROC CompileShader;
+  PFNCREATEPROGRAMPROC CreateProgram;
+  PFNCREATESHADERPROC CreateShader;
+  PFNDELETEPROGRAMPROC DeleteProgram;
+  PFNDELETESHADERPROC DeleteShader;
+  PFNDETACHSHADERPROC DetachShader;
+  PFNDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+  PFNENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+  PFNGETACTIVEATTRIBPROC GetActiveAttrib;
+  PFNGETACTIVEUNIFORMPROC GetActiveUniform;
+  PFNGETATTACHEDSHADERSPROC GetAttachedShaders;
+  PFNGETATTRIBLOCATIONPROC GetAttribLocation;
+  PFNGETPROGRAMIVPROC GetProgramiv;
+  PFNGETPROGRAMINFOLOGPROC GetProgramInfoLog;
+  PFNGETSHADERIVPROC GetShaderiv;
+  PFNGETSHADERINFOLOGPROC GetShaderInfoLog;
+  PFNGETSHADERSOURCEPROC GetShaderSource;
+  PFNGETUNIFORMLOCATIONPROC GetUniformLocation;
+  PFNGETUNIFORMFVPROC GetUniformfv;
+  PFNGETUNIFORMIVPROC GetUniformiv;
+  PFNGETVERTEXATTRIBDVPROC GetVertexAttribdv;
+  PFNGETVERTEXATTRIBFVPROC GetVertexAttribfv;
+  PFNGETVERTEXATTRIBIVPROC GetVertexAttribiv;
+  PFNGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
+  PFNISPROGRAMPROC IsProgram;
+  PFNISSHADERPROC IsShader;
+  PFNLINKPROGRAMPROC LinkProgram;
+  PFNSHADERSOURCEPROC ShaderSource;
+  PFNUSEPROGRAMPROC UseProgram;
+  PFNUNIFORM1FPROC Uniform1f;
+  PFNUNIFORM2FPROC Uniform2f;
+  PFNUNIFORM3FPROC Uniform3f;
+  PFNUNIFORM4FPROC Uniform4f;
+  PFNUNIFORM1IPROC Uniform1i;
+  PFNUNIFORM2IPROC Uniform2i;
+  PFNUNIFORM3IPROC Uniform3i;
+  PFNUNIFORM4IPROC Uniform4i;
+  PFNUNIFORM1FVPROC Uniform1fv;
+  PFNUNIFORM2FVPROC Uniform2fv;
+  PFNUNIFORM3FVPROC Uniform3fv;
+  PFNUNIFORM4FVPROC Uniform4fv;
+  PFNUNIFORM1IVPROC Uniform1iv;
+  PFNUNIFORM2IVPROC Uniform2iv;
+  PFNUNIFORM3IVPROC Uniform3iv;
+  PFNUNIFORM4IVPROC Uniform4iv;
+  PFNUNIFORMMATRIX2FVPROC UniformMatrix2fv;
+  PFNUNIFORMMATRIX3FVPROC UniformMatrix3fv;
+  PFNUNIFORMMATRIX4FVPROC UniformMatrix4fv;
+  PFNVALIDATEPROGRAMPROC ValidateProgram;
+  PFNVERTEXATTRIBPOINTERPROC VertexAttribPointer;
+
+  // Extension: 2.1
+  PFNUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv;
+  PFNUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv;
+  PFNUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv;
+  PFNUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv;
+  PFNUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv;
+  PFNUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv;
+
+  // Extension: ARB_vertex_array_object
+  PFNBINDVERTEXARRAYPROC BindVertexArray;
+  PFNDELETEVERTEXARRAYSPROC DeleteVertexArrays;
+  PFNGENVERTEXARRAYSPROC GenVertexArrays;
+  PFNISVERTEXARRAYPROC IsVertexArray;
+
+  // Extension: ARB_map_buffer_range
+  PFNMAPBUFFERRANGEPROC MapBufferRange;
+  PFNFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange;
+
+  // Extension: ARB_framebuffer_object
+  PFNISRENDERBUFFERPROC IsRenderbuffer;
+  PFNBINDRENDERBUFFERPROC BindRenderbuffer;
+  PFNDELETERENDERBUFFERSPROC DeleteRenderbuffers;
+  PFNGENRENDERBUFFERSPROC GenRenderbuffers;
+  PFNRENDERBUFFERSTORAGEPROC RenderbufferStorage;
+  PFNGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
+  PFNISFRAMEBUFFERPROC IsFramebuffer;
+  PFNBINDFRAMEBUFFERPROC BindFramebuffer;
+  PFNDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
+  PFNGENFRAMEBUFFERSPROC GenFramebuffers;
+  PFNCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
+  PFNFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D;
+  PFNFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
+  PFNFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D;
+  PFNFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
+  PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
+  PFNGENERATEMIPMAPPROC GenerateMipmap;
+  PFNBLITFRAMEBUFFERPROC BlitFramebuffer;
+  PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample;
+  PFNFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer;
+
+  // Extension: 3.0
+  PFNCOLORMASKIPROC ColorMaski;
+  PFNGETBOOLEANI_VPROC GetBooleani_v;
+  PFNGETINTEGERI_VPROC GetIntegeri_v;
+  PFNENABLEIPROC Enablei;
+  PFNDISABLEIPROC Disablei;
+  PFNISENABLEDIPROC IsEnabledi;
+  PFNBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback;
+  PFNENDTRANSFORMFEEDBACKPROC EndTransformFeedback;
+  PFNBINDBUFFERRANGEPROC BindBufferRange;
+  PFNBINDBUFFERBASEPROC BindBufferBase;
+  PFNTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings;
+  PFNGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying;
+  PFNCLAMPCOLORPROC ClampColor;
+  PFNBEGINCONDITIONALRENDERPROC BeginConditionalRender;
+  PFNENDCONDITIONALRENDERPROC EndConditionalRender;
+  PFNVERTEXATTRIBIPOINTERPROC VertexAttribIPointer;
+  PFNGETVERTEXATTRIBIIVPROC GetVertexAttribIiv;
+  PFNGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv;
+  PFNVERTEXATTRIBI1IPROC VertexAttribI1i;
+  PFNVERTEXATTRIBI2IPROC VertexAttribI2i;
+  PFNVERTEXATTRIBI3IPROC VertexAttribI3i;
+  PFNVERTEXATTRIBI4IPROC VertexAttribI4i;
+  PFNVERTEXATTRIBI1UIPROC VertexAttribI1ui;
+  PFNVERTEXATTRIBI2UIPROC VertexAttribI2ui;
+  PFNVERTEXATTRIBI3UIPROC VertexAttribI3ui;
+  PFNVERTEXATTRIBI4UIPROC VertexAttribI4ui;
+  PFNVERTEXATTRIBI1IVPROC VertexAttribI1iv;
+  PFNVERTEXATTRIBI2IVPROC VertexAttribI2iv;
+  PFNVERTEXATTRIBI3IVPROC VertexAttribI3iv;
+  PFNVERTEXATTRIBI4IVPROC VertexAttribI4iv;
+  PFNVERTEXATTRIBI1UIVPROC VertexAttribI1uiv;
+  PFNVERTEXATTRIBI2UIVPROC VertexAttribI2uiv;
+  PFNVERTEXATTRIBI3UIVPROC VertexAttribI3uiv;
+  PFNVERTEXATTRIBI4UIVPROC VertexAttribI4uiv;
+  PFNVERTEXATTRIBI4BVPROC VertexAttribI4bv;
+  PFNVERTEXATTRIBI4SVPROC VertexAttribI4sv;
+  PFNVERTEXATTRIBI4UBVPROC VertexAttribI4ubv;
+  PFNVERTEXATTRIBI4USVPROC VertexAttribI4usv;
+  PFNGETUNIFORMUIVPROC GetUniformuiv;
+  PFNBINDFRAGDATALOCATIONPROC BindFragDataLocation;
+  PFNGETFRAGDATALOCATIONPROC GetFragDataLocation;
+  PFNUNIFORM1UIPROC Uniform1ui;
+  PFNUNIFORM2UIPROC Uniform2ui;
+  PFNUNIFORM3UIPROC Uniform3ui;
+  PFNUNIFORM4UIPROC Uniform4ui;
+  PFNUNIFORM1UIVPROC Uniform1uiv;
+  PFNUNIFORM2UIVPROC Uniform2uiv;
+  PFNUNIFORM3UIVPROC Uniform3uiv;
+  PFNUNIFORM4UIVPROC Uniform4uiv;
+  PFNTEXPARAMETERIIVPROC TexParameterIiv;
+  PFNTEXPARAMETERIUIVPROC TexParameterIuiv;
+  PFNGETTEXPARAMETERIIVPROC GetTexParameterIiv;
+  PFNGETTEXPARAMETERIUIVPROC GetTexParameterIuiv;
+  PFNCLEARBUFFERIVPROC ClearBufferiv;
+  PFNCLEARBUFFERUIVPROC ClearBufferuiv;
+  PFNCLEARBUFFERFVPROC ClearBufferfv;
+  PFNCLEARBUFFERFIPROC ClearBufferfi;
+  PFNGETSTRINGIPROC GetStringi;
+
+  // Extension: ARB_uniform_buffer_object
+  PFNGETUNIFORMINDICESPROC GetUniformIndices;
+  PFNGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv;
+  PFNGETACTIVEUNIFORMNAMEPROC GetActiveUniformName;
+  PFNGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex;
+  PFNGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv;
+  PFNGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName;
+  PFNUNIFORMBLOCKBINDINGPROC UniformBlockBinding;
+
+  // Extension: ARB_copy_buffer
+  PFNCOPYBUFFERSUBDATAPROC CopyBufferSubData;
+
+  // Extension: 3.1
+  PFNDRAWARRAYSINSTANCEDPROC DrawArraysInstanced;
+  PFNDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced;
+  PFNTEXBUFFERPROC TexBuffer;
+  PFNPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex;
+
+  // Legacy
+  PFNENABLECLIENTSTATEPROC EnableClientState;
+  PFNDISABLECLIENTSTATEPROC DisableClientState;
+  PFNVERTEXPOINTERPROC VertexPointer;
+  PFNNORMALPOINTERPROC NormalPointer;
+  PFNCOLORPOINTERPROC ColorPointer;
+  PFNTEXCOORDPOINTERPROC TexCoordPointer;
+
+  PFNTEXENVIPROC TexEnvi;
+
+  PFNMATRIXMODEPROC MatrixMode;
+  PFNLOADIDENTITYPROC LoadIdentity;
+  PFNORTHOPROC Ortho;
+
+  PFNCOLOR3DPROC Color3d;
+
+
+  // Extension: 1.1
+  static void CODEGEN_FUNCPTR Switch_CullFace(GLenum mode)
+  {
+    CullFace = (PFNCULLFACEPROC)IntGetProcAddress("glCullFace");
+    CullFace(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FrontFace(GLenum mode)
+  {
+    FrontFace = (PFNFRONTFACEPROC)IntGetProcAddress("glFrontFace");
+    FrontFace(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Hint(GLenum target, GLenum mode)
+  {
+    Hint = (PFNHINTPROC)IntGetProcAddress("glHint");
+    Hint(target, mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_LineWidth(GLfloat width)
+  {
+    LineWidth = (PFNLINEWIDTHPROC)IntGetProcAddress("glLineWidth");
+    LineWidth(width);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PointSize(GLfloat size)
+  {
+    PointSize = (PFNPOINTSIZEPROC)IntGetProcAddress("glPointSize");
+    PointSize(size);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PolygonMode(GLenum face, GLenum mode)
+  {
+    PolygonMode = (PFNPOLYGONMODEPROC)IntGetProcAddress("glPolygonMode");
+    PolygonMode(face, mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+  {
+    Scissor = (PFNSCISSORPROC)IntGetProcAddress("glScissor");
+    Scissor(x, y, width, height);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameterf(GLenum target, GLenum pname, GLfloat param)
+  {
+    TexParameterf = (PFNTEXPARAMETERFPROC)IntGetProcAddress("glTexParameterf");
+    TexParameterf(target, pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+  {
+    TexParameterfv = (PFNTEXPARAMETERFVPROC)IntGetProcAddress("glTexParameterfv");
+    TexParameterfv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameteri(GLenum target, GLenum pname, GLint param)
+  {
+    TexParameteri = (PFNTEXPARAMETERIPROC)IntGetProcAddress("glTexParameteri");
+    TexParameteri(target, pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
+  {
+    TexParameteriv = (PFNTEXPARAMETERIVPROC)IntGetProcAddress("glTexParameteriv");
+    TexParameteriv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    TexImage1D = (PFNTEXIMAGE1DPROC)IntGetProcAddress("glTexImage1D");
+    TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    TexImage2D = (PFNTEXIMAGE2DPROC)IntGetProcAddress("glTexImage2D");
+    TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawBuffer(GLenum mode)
+  {
+    DrawBuffer = (PFNDRAWBUFFERPROC)IntGetProcAddress("glDrawBuffer");
+    DrawBuffer(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Clear(GLbitfield mask)
+  {
+    Clear = (PFNCLEARPROC)IntGetProcAddress("glClear");
+    Clear(mask);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+  {
+    ClearColor = (PFNCLEARCOLORPROC)IntGetProcAddress("glClearColor");
+    ClearColor(red, green, blue, alpha);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearStencil(GLint s)
+  {
+    ClearStencil = (PFNCLEARSTENCILPROC)IntGetProcAddress("glClearStencil");
+    ClearStencil(s);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearDepth(GLdouble depth)
+  {
+    ClearDepth = (PFNCLEARDEPTHPROC)IntGetProcAddress("glClearDepth");
+    ClearDepth(depth);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilMask(GLuint mask)
+  {
+    StencilMask = (PFNSTENCILMASKPROC)IntGetProcAddress("glStencilMask");
+    StencilMask(mask);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+  {
+    ColorMask = (PFNCOLORMASKPROC)IntGetProcAddress("glColorMask");
+    ColorMask(red, green, blue, alpha);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DepthMask(GLboolean flag)
+  {
+    DepthMask = (PFNDEPTHMASKPROC)IntGetProcAddress("glDepthMask");
+    DepthMask(flag);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Disable(GLenum cap)
+  {
+    Disable = (PFNDISABLEPROC)IntGetProcAddress("glDisable");
+    Disable(cap);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Enable(GLenum cap)
+  {
+    Enable = (PFNENABLEPROC)IntGetProcAddress("glEnable");
+    Enable(cap);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Finish()
+  {
+    Finish = (PFNFINISHPROC)IntGetProcAddress("glFinish");
+    Finish();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Flush()
+  {
+    Flush = (PFNFLUSHPROC)IntGetProcAddress("glFlush");
+    Flush();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BlendFunc(GLenum sfactor, GLenum dfactor)
+  {
+    BlendFunc = (PFNBLENDFUNCPROC)IntGetProcAddress("glBlendFunc");
+    BlendFunc(sfactor, dfactor);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_LogicOp(GLenum opcode)
+  {
+    LogicOp = (PFNLOGICOPPROC)IntGetProcAddress("glLogicOp");
+    LogicOp(opcode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilFunc(GLenum func, GLint ref, GLuint mask)
+  {
+    StencilFunc = (PFNSTENCILFUNCPROC)IntGetProcAddress("glStencilFunc");
+    StencilFunc(func, ref, mask);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+  {
+    StencilOp = (PFNSTENCILOPPROC)IntGetProcAddress("glStencilOp");
+    StencilOp(fail, zfail, zpass);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DepthFunc(GLenum func)
+  {
+    DepthFunc = (PFNDEPTHFUNCPROC)IntGetProcAddress("glDepthFunc");
+    DepthFunc(func);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PixelStoref(GLenum pname, GLfloat param)
+  {
+    PixelStoref = (PFNPIXELSTOREFPROC)IntGetProcAddress("glPixelStoref");
+    PixelStoref(pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PixelStorei(GLenum pname, GLint param)
+  {
+    PixelStorei = (PFNPIXELSTOREIPROC)IntGetProcAddress("glPixelStorei");
+    PixelStorei(pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ReadBuffer(GLenum mode)
+  {
+    ReadBuffer = (PFNREADBUFFERPROC)IntGetProcAddress("glReadBuffer");
+    ReadBuffer(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
+  {
+    ReadPixels = (PFNREADPIXELSPROC)IntGetProcAddress("glReadPixels");
+    ReadPixels(x, y, width, height, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetBooleanv(GLenum pname, GLboolean *params)
+  {
+    GetBooleanv = (PFNGETBOOLEANVPROC)IntGetProcAddress("glGetBooleanv");
+    GetBooleanv(pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetDoublev(GLenum pname, GLdouble *params)
+  {
+    GetDoublev = (PFNGETDOUBLEVPROC)IntGetProcAddress("glGetDoublev");
+    GetDoublev(pname, params);
+  }
+
+  static GLenum CODEGEN_FUNCPTR Switch_GetError()
+  {
+    GetError = (PFNGETERRORPROC)IntGetProcAddress("glGetError");
+    return GetError();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetFloatv(GLenum pname, GLfloat *params)
+  {
+    GetFloatv = (PFNGETFLOATVPROC)IntGetProcAddress("glGetFloatv");
+    GetFloatv(pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetIntegerv(GLenum pname, GLint *params)
+  {
+    GetIntegerv = (PFNGETINTEGERVPROC)IntGetProcAddress("glGetIntegerv");
+    GetIntegerv(pname, params);
+  }
+
+  static const GLubyte * CODEGEN_FUNCPTR Switch_GetString(GLenum name)
+  {
+    GetString = (PFNGETSTRINGPROC)IntGetProcAddress("glGetString");
+    return GetString(name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
+  {
+    GetTexImage = (PFNGETTEXIMAGEPROC)IntGetProcAddress("glGetTexImage");
+    GetTexImage(target, level, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+  {
+    GetTexParameterfv = (PFNGETTEXPARAMETERFVPROC)IntGetProcAddress("glGetTexParameterfv");
+    GetTexParameterfv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+  {
+    GetTexParameteriv = (PFNGETTEXPARAMETERIVPROC)IntGetProcAddress("glGetTexParameteriv");
+    GetTexParameteriv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+  {
+    GetTexLevelParameterfv = (PFNGETTEXLEVELPARAMETERFVPROC)IntGetProcAddress("glGetTexLevelParameterfv");
+    GetTexLevelParameterfv(target, level, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+  {
+    GetTexLevelParameteriv = (PFNGETTEXLEVELPARAMETERIVPROC)IntGetProcAddress("glGetTexLevelParameteriv");
+    GetTexLevelParameteriv(target, level, pname, params);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsEnabled(GLenum cap)
+  {
+    IsEnabled = (PFNISENABLEDPROC)IntGetProcAddress("glIsEnabled");
+    return IsEnabled(cap);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DepthRange(GLdouble ren_near, GLdouble ren_far)
+  {
+    DepthRange = (PFNDEPTHRANGEPROC)IntGetProcAddress("glDepthRange");
+    DepthRange(ren_near, ren_far);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+  {
+    Viewport = (PFNVIEWPORTPROC)IntGetProcAddress("glViewport");
+    Viewport(x, y, width, height);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawArrays(GLenum mode, GLint first, GLsizei count)
+  {
+    DrawArrays = (PFNDRAWARRAYSPROC)IntGetProcAddress("glDrawArrays");
+    DrawArrays(mode, first, count);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+  {
+    DrawElements = (PFNDRAWELEMENTSPROC)IntGetProcAddress("glDrawElements");
+    DrawElements(mode, count, type, indices);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetPointerv(GLenum pname, GLvoid* *params)
+  {
+    GetPointerv = (PFNGETPOINTERVPROC)IntGetProcAddress("glGetPointerv");
+    GetPointerv(pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PolygonOffset(GLfloat factor, GLfloat units)
+  {
+    PolygonOffset = (PFNPOLYGONOFFSETPROC)IntGetProcAddress("glPolygonOffset");
+    PolygonOffset(factor, units);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+  {
+    CopyTexImage1D = (PFNCOPYTEXIMAGE1DPROC)IntGetProcAddress("glCopyTexImage1D");
+    CopyTexImage1D(target, level, internalformat, x, y, width, border);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+  {
+    CopyTexImage2D = (PFNCOPYTEXIMAGE2DPROC)IntGetProcAddress("glCopyTexImage2D");
+    CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+  {
+    CopyTexSubImage1D = (PFNCOPYTEXSUBIMAGE1DPROC)IntGetProcAddress("glCopyTexSubImage1D");
+    CopyTexSubImage1D(target, level, xoffset, x, y, width);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+  {
+    CopyTexSubImage2D = (PFNCOPYTEXSUBIMAGE2DPROC)IntGetProcAddress("glCopyTexSubImage2D");
+    CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    TexSubImage1D = (PFNTEXSUBIMAGE1DPROC)IntGetProcAddress("glTexSubImage1D");
+    TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    TexSubImage2D = (PFNTEXSUBIMAGE2DPROC)IntGetProcAddress("glTexSubImage2D");
+    TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindTexture(GLenum target, GLuint texture)
+  {
+    BindTexture = (PFNBINDTEXTUREPROC)IntGetProcAddress("glBindTexture");
+    BindTexture(target, texture);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteTextures(GLsizei n, const GLuint *textures)
+  {
+    DeleteTextures = (PFNDELETETEXTURESPROC)IntGetProcAddress("glDeleteTextures");
+    DeleteTextures(n, textures);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenTextures(GLsizei n, GLuint *textures)
+  {
+    GenTextures = (PFNGENTEXTURESPROC)IntGetProcAddress("glGenTextures");
+    GenTextures(n, textures);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsTexture(GLuint texture)
+  {
+    IsTexture = (PFNISTEXTUREPROC)IntGetProcAddress("glIsTexture");
+    return IsTexture(texture);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Indexub(GLubyte c)
+  {
+    Indexub = (PFNINDEXUBPROC)IntGetProcAddress("glIndexub");
+    Indexub(c);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Indexubv(const GLubyte *c)
+  {
+    Indexubv = (PFNINDEXUBVPROC)IntGetProcAddress("glIndexubv");
+    Indexubv(c);
+  }
+
+
+  // Extension: 1.2
+  static void CODEGEN_FUNCPTR Switch_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+  {
+    BlendColor = (PFNBLENDCOLORPROC)IntGetProcAddress("glBlendColor");
+    BlendColor(red, green, blue, alpha);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BlendEquation(GLenum mode)
+  {
+    BlendEquation = (PFNBLENDEQUATIONPROC)IntGetProcAddress("glBlendEquation");
+    BlendEquation(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
+  {
+    DrawRangeElements = (PFNDRAWRANGEELEMENTSPROC)IntGetProcAddress("glDrawRangeElements");
+    DrawRangeElements(mode, start, end, count, type, indices);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
+  {
+    TexSubImage3D = (PFNTEXSUBIMAGE3DPROC)IntGetProcAddress("glTexSubImage3D");
+    TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+  {
+    CopyTexSubImage3D = (PFNCOPYTEXSUBIMAGE3DPROC)IntGetProcAddress("glCopyTexSubImage3D");
+    CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+  }
+
+
+  // Extension: 1.3
+  static void CODEGEN_FUNCPTR Switch_ActiveTexture(GLenum texture)
+  {
+    ActiveTexture = (PFNACTIVETEXTUREPROC)IntGetProcAddress("glActiveTexture");
+    ActiveTexture(texture);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_SampleCoverage(GLfloat value, GLboolean invert)
+  {
+    SampleCoverage = (PFNSAMPLECOVERAGEPROC)IntGetProcAddress("glSampleCoverage");
+    SampleCoverage(value, invert);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexImage3D = (PFNCOMPRESSEDTEXIMAGE3DPROC)IntGetProcAddress("glCompressedTexImage3D");
+    CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexImage2D = (PFNCOMPRESSEDTEXIMAGE2DPROC)IntGetProcAddress("glCompressedTexImage2D");
+    CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexImage1D = (PFNCOMPRESSEDTEXIMAGE1DPROC)IntGetProcAddress("glCompressedTexImage1D");
+    CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexSubImage3D = (PFNCOMPRESSEDTEXSUBIMAGE3DPROC)IntGetProcAddress("glCompressedTexSubImage3D");
+    CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexSubImage2D = (PFNCOMPRESSEDTEXSUBIMAGE2DPROC)IntGetProcAddress("glCompressedTexSubImage2D");
+    CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
+  {
+    CompressedTexSubImage1D = (PFNCOMPRESSEDTEXSUBIMAGE1DPROC)IntGetProcAddress("glCompressedTexSubImage1D");
+    CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
+  {
+    GetCompressedTexImage = (PFNGETCOMPRESSEDTEXIMAGEPROC)IntGetProcAddress("glGetCompressedTexImage");
+    GetCompressedTexImage(target, level, img);
+  }
+
+
+  // Extension: 1.4
+  static void CODEGEN_FUNCPTR Switch_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+  {
+    BlendFuncSeparate = (PFNBLENDFUNCSEPARATEPROC)IntGetProcAddress("glBlendFuncSeparate");
+    BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_MultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
+  {
+    MultiDrawArrays = (PFNMULTIDRAWARRAYSPROC)IntGetProcAddress("glMultiDrawArrays");
+    MultiDrawArrays(mode, first, count, drawcount);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
+  {
+    MultiDrawElements = (PFNMULTIDRAWELEMENTSPROC)IntGetProcAddress("glMultiDrawElements");
+    MultiDrawElements(mode, count, type, indices, drawcount);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PointParameterf(GLenum pname, GLfloat param)
+  {
+    PointParameterf = (PFNPOINTPARAMETERFPROC)IntGetProcAddress("glPointParameterf");
+    PointParameterf(pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PointParameterfv(GLenum pname, const GLfloat *params)
+  {
+    PointParameterfv = (PFNPOINTPARAMETERFVPROC)IntGetProcAddress("glPointParameterfv");
+    PointParameterfv(pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PointParameteri(GLenum pname, GLint param)
+  {
+    PointParameteri = (PFNPOINTPARAMETERIPROC)IntGetProcAddress("glPointParameteri");
+    PointParameteri(pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PointParameteriv(GLenum pname, const GLint *params)
+  {
+    PointParameteriv = (PFNPOINTPARAMETERIVPROC)IntGetProcAddress("glPointParameteriv");
+    PointParameteriv(pname, params);
+  }
+
+
+  // Extension: 1.5
+  static void CODEGEN_FUNCPTR Switch_GenQueries(GLsizei n, GLuint *ids)
+  {
+    GenQueries = (PFNGENQUERIESPROC)IntGetProcAddress("glGenQueries");
+    GenQueries(n, ids);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteQueries(GLsizei n, const GLuint *ids)
+  {
+    DeleteQueries = (PFNDELETEQUERIESPROC)IntGetProcAddress("glDeleteQueries");
+    DeleteQueries(n, ids);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsQuery(GLuint id)
+  {
+    IsQuery = (PFNISQUERYPROC)IntGetProcAddress("glIsQuery");
+    return IsQuery(id);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BeginQuery(GLenum target, GLuint id)
+  {
+    BeginQuery = (PFNBEGINQUERYPROC)IntGetProcAddress("glBeginQuery");
+    BeginQuery(target, id);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_EndQuery(GLenum target)
+  {
+    EndQuery = (PFNENDQUERYPROC)IntGetProcAddress("glEndQuery");
+    EndQuery(target);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetQueryiv(GLenum target, GLenum pname, GLint *params)
+  {
+    GetQueryiv = (PFNGETQUERYIVPROC)IntGetProcAddress("glGetQueryiv");
+    GetQueryiv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
+  {
+    GetQueryObjectiv = (PFNGETQUERYOBJECTIVPROC)IntGetProcAddress("glGetQueryObjectiv");
+    GetQueryObjectiv(id, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
+  {
+    GetQueryObjectuiv = (PFNGETQUERYOBJECTUIVPROC)IntGetProcAddress("glGetQueryObjectuiv");
+    GetQueryObjectuiv(id, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindBuffer(GLenum target, GLuint buffer)
+  {
+    BindBuffer = (PFNBINDBUFFERPROC)IntGetProcAddress("glBindBuffer");
+    BindBuffer(target, buffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteBuffers(GLsizei n, const GLuint *buffers)
+  {
+    DeleteBuffers = (PFNDELETEBUFFERSPROC)IntGetProcAddress("glDeleteBuffers");
+    DeleteBuffers(n, buffers);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenBuffers(GLsizei n, GLuint *buffers)
+  {
+    GenBuffers = (PFNGENBUFFERSPROC)IntGetProcAddress("glGenBuffers");
+    GenBuffers(n, buffers);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsBuffer(GLuint buffer)
+  {
+    IsBuffer = (PFNISBUFFERPROC)IntGetProcAddress("glIsBuffer");
+    return IsBuffer(buffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
+  {
+    BufferData = (PFNBUFFERDATAPROC)IntGetProcAddress("glBufferData");
+    BufferData(target, size, data, usage);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
+  {
+    BufferSubData = (PFNBUFFERSUBDATAPROC)IntGetProcAddress("glBufferSubData");
+    BufferSubData(target, offset, size, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
+  {
+    GetBufferSubData = (PFNGETBUFFERSUBDATAPROC)IntGetProcAddress("glGetBufferSubData");
+    GetBufferSubData(target, offset, size, data);
+  }
+
+  static GLvoid* CODEGEN_FUNCPTR Switch_MapBuffer(GLenum target, GLenum access)
+  {
+    MapBuffer = (PFNMAPBUFFERPROC)IntGetProcAddress("glMapBuffer");
+    return MapBuffer(target, access);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_UnmapBuffer(GLenum target)
+  {
+    UnmapBuffer = (PFNUNMAPBUFFERPROC)IntGetProcAddress("glUnmapBuffer");
+    return UnmapBuffer(target);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
+  {
+    GetBufferParameteriv = (PFNGETBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetBufferParameteriv");
+    GetBufferParameteriv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
+  {
+    GetBufferPointerv = (PFNGETBUFFERPOINTERVPROC)IntGetProcAddress("glGetBufferPointerv");
+    GetBufferPointerv(target, pname, params);
+  }
+
+
+  // Extension: 2.0
+  static void CODEGEN_FUNCPTR Switch_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+  {
+    BlendEquationSeparate = (PFNBLENDEQUATIONSEPARATEPROC)IntGetProcAddress("glBlendEquationSeparate");
+    BlendEquationSeparate(modeRGB, modeAlpha);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawBuffers(GLsizei n, const GLenum *bufs)
+  {
+    DrawBuffers = (PFNDRAWBUFFERSPROC)IntGetProcAddress("glDrawBuffers");
+    DrawBuffers(n, bufs);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
+  {
+    StencilOpSeparate = (PFNSTENCILOPSEPARATEPROC)IntGetProcAddress("glStencilOpSeparate");
+    StencilOpSeparate(face, sfail, dpfail, dppass);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+  {
+    StencilFuncSeparate = (PFNSTENCILFUNCSEPARATEPROC)IntGetProcAddress("glStencilFuncSeparate");
+    StencilFuncSeparate(face, func, ref, mask);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_StencilMaskSeparate(GLenum face, GLuint mask)
+  {
+    StencilMaskSeparate = (PFNSTENCILMASKSEPARATEPROC)IntGetProcAddress("glStencilMaskSeparate");
+    StencilMaskSeparate(face, mask);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_AttachShader(GLuint program, GLuint shader)
+  {
+    AttachShader = (PFNATTACHSHADERPROC)IntGetProcAddress("glAttachShader");
+    AttachShader(program, shader);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
+  {
+    BindAttribLocation = (PFNBINDATTRIBLOCATIONPROC)IntGetProcAddress("glBindAttribLocation");
+    BindAttribLocation(program, index, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_CompileShader(GLuint shader)
+  {
+    CompileShader = (PFNCOMPILESHADERPROC)IntGetProcAddress("glCompileShader");
+    CompileShader(shader);
+  }
+
+  static GLuint CODEGEN_FUNCPTR Switch_CreateProgram()
+  {
+    CreateProgram = (PFNCREATEPROGRAMPROC)IntGetProcAddress("glCreateProgram");
+    return CreateProgram();
+  }
+
+  static GLuint CODEGEN_FUNCPTR Switch_CreateShader(GLenum type)
+  {
+    CreateShader = (PFNCREATESHADERPROC)IntGetProcAddress("glCreateShader");
+    return CreateShader(type);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteProgram(GLuint program)
+  {
+    DeleteProgram = (PFNDELETEPROGRAMPROC)IntGetProcAddress("glDeleteProgram");
+    DeleteProgram(program);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteShader(GLuint shader)
+  {
+    DeleteShader = (PFNDELETESHADERPROC)IntGetProcAddress("glDeleteShader");
+    DeleteShader(shader);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DetachShader(GLuint program, GLuint shader)
+  {
+    DetachShader = (PFNDETACHSHADERPROC)IntGetProcAddress("glDetachShader");
+    DetachShader(program, shader);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DisableVertexAttribArray(GLuint index)
+  {
+    DisableVertexAttribArray = (PFNDISABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glDisableVertexAttribArray");
+    DisableVertexAttribArray(index);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_EnableVertexAttribArray(GLuint index)
+  {
+    EnableVertexAttribArray = (PFNENABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glEnableVertexAttribArray");
+    EnableVertexAttribArray(index);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+  {
+    GetActiveAttrib = (PFNGETACTIVEATTRIBPROC)IntGetProcAddress("glGetActiveAttrib");
+    GetActiveAttrib(program, index, bufSize, length, size, type, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+  {
+    GetActiveUniform = (PFNGETACTIVEUNIFORMPROC)IntGetProcAddress("glGetActiveUniform");
+    GetActiveUniform(program, index, bufSize, length, size, type, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
+  {
+    GetAttachedShaders = (PFNGETATTACHEDSHADERSPROC)IntGetProcAddress("glGetAttachedShaders");
+    GetAttachedShaders(program, maxCount, count, obj);
+  }
+
+  static GLint CODEGEN_FUNCPTR Switch_GetAttribLocation(GLuint program, const GLchar *name)
+  {
+    GetAttribLocation = (PFNGETATTRIBLOCATIONPROC)IntGetProcAddress("glGetAttribLocation");
+    return GetAttribLocation(program, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetProgramiv(GLuint program, GLenum pname, GLint *params)
+  {
+    GetProgramiv = (PFNGETPROGRAMIVPROC)IntGetProcAddress("glGetProgramiv");
+    GetProgramiv(program, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+  {
+    GetProgramInfoLog = (PFNGETPROGRAMINFOLOGPROC)IntGetProcAddress("glGetProgramInfoLog");
+    GetProgramInfoLog(program, bufSize, length, infoLog);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+  {
+    GetShaderiv = (PFNGETSHADERIVPROC)IntGetProcAddress("glGetShaderiv");
+    GetShaderiv(shader, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+  {
+    GetShaderInfoLog = (PFNGETSHADERINFOLOGPROC)IntGetProcAddress("glGetShaderInfoLog");
+    GetShaderInfoLog(shader, bufSize, length, infoLog);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
+  {
+    GetShaderSource = (PFNGETSHADERSOURCEPROC)IntGetProcAddress("glGetShaderSource");
+    GetShaderSource(shader, bufSize, length, source);
+  }
+
+  static GLint CODEGEN_FUNCPTR Switch_GetUniformLocation(GLuint program, const GLchar *name)
+  {
+    GetUniformLocation = (PFNGETUNIFORMLOCATIONPROC)IntGetProcAddress("glGetUniformLocation");
+    return GetUniformLocation(program, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetUniformfv(GLuint program, GLint location, GLfloat *params)
+  {
+    GetUniformfv = (PFNGETUNIFORMFVPROC)IntGetProcAddress("glGetUniformfv");
+    GetUniformfv(program, location, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetUniformiv(GLuint program, GLint location, GLint *params)
+  {
+    GetUniformiv = (PFNGETUNIFORMIVPROC)IntGetProcAddress("glGetUniformiv");
+    GetUniformiv(program, location, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
+  {
+    GetVertexAttribdv = (PFNGETVERTEXATTRIBDVPROC)IntGetProcAddress("glGetVertexAttribdv");
+    GetVertexAttribdv(index, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
+  {
+    GetVertexAttribfv = (PFNGETVERTEXATTRIBFVPROC)IntGetProcAddress("glGetVertexAttribfv");
+    GetVertexAttribfv(index, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
+  {
+    GetVertexAttribiv = (PFNGETVERTEXATTRIBIVPROC)IntGetProcAddress("glGetVertexAttribiv");
+    GetVertexAttribiv(index, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
+  {
+    GetVertexAttribPointerv = (PFNGETVERTEXATTRIBPOINTERVPROC)IntGetProcAddress("glGetVertexAttribPointerv");
+    GetVertexAttribPointerv(index, pname, pointer);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsProgram(GLuint program)
+  {
+    IsProgram = (PFNISPROGRAMPROC)IntGetProcAddress("glIsProgram");
+    return IsProgram(program);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsShader(GLuint shader)
+  {
+    IsShader = (PFNISSHADERPROC)IntGetProcAddress("glIsShader");
+    return IsShader(shader);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_LinkProgram(GLuint program)
+  {
+    LinkProgram = (PFNLINKPROGRAMPROC)IntGetProcAddress("glLinkProgram");
+    LinkProgram(program);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
+  {
+    ShaderSource = (PFNSHADERSOURCEPROC)IntGetProcAddress("glShaderSource");
+    ShaderSource(shader, count, string, length);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UseProgram(GLuint program)
+  {
+    UseProgram = (PFNUSEPROGRAMPROC)IntGetProcAddress("glUseProgram");
+    UseProgram(program);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1f(GLint location, GLfloat v0)
+  {
+    Uniform1f = (PFNUNIFORM1FPROC)IntGetProcAddress("glUniform1f");
+    Uniform1f(location, v0);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
+  {
+    Uniform2f = (PFNUNIFORM2FPROC)IntGetProcAddress("glUniform2f");
+    Uniform2f(location, v0, v1);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+  {
+    Uniform3f = (PFNUNIFORM3FPROC)IntGetProcAddress("glUniform3f");
+    Uniform3f(location, v0, v1, v2);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+  {
+    Uniform4f = (PFNUNIFORM4FPROC)IntGetProcAddress("glUniform4f");
+    Uniform4f(location, v0, v1, v2, v3);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1i(GLint location, GLint v0)
+  {
+    Uniform1i = (PFNUNIFORM1IPROC)IntGetProcAddress("glUniform1i");
+    Uniform1i(location, v0);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2i(GLint location, GLint v0, GLint v1)
+  {
+    Uniform2i = (PFNUNIFORM2IPROC)IntGetProcAddress("glUniform2i");
+    Uniform2i(location, v0, v1);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
+  {
+    Uniform3i = (PFNUNIFORM3IPROC)IntGetProcAddress("glUniform3i");
+    Uniform3i(location, v0, v1, v2);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+  {
+    Uniform4i = (PFNUNIFORM4IPROC)IntGetProcAddress("glUniform4i");
+    Uniform4i(location, v0, v1, v2, v3);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
+  {
+    Uniform1fv = (PFNUNIFORM1FVPROC)IntGetProcAddress("glUniform1fv");
+    Uniform1fv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
+  {
+    Uniform2fv = (PFNUNIFORM2FVPROC)IntGetProcAddress("glUniform2fv");
+    Uniform2fv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
+  {
+    Uniform3fv = (PFNUNIFORM3FVPROC)IntGetProcAddress("glUniform3fv");
+    Uniform3fv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
+  {
+    Uniform4fv = (PFNUNIFORM4FVPROC)IntGetProcAddress("glUniform4fv");
+    Uniform4fv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1iv(GLint location, GLsizei count, const GLint *value)
+  {
+    Uniform1iv = (PFNUNIFORM1IVPROC)IntGetProcAddress("glUniform1iv");
+    Uniform1iv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2iv(GLint location, GLsizei count, const GLint *value)
+  {
+    Uniform2iv = (PFNUNIFORM2IVPROC)IntGetProcAddress("glUniform2iv");
+    Uniform2iv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3iv(GLint location, GLsizei count, const GLint *value)
+  {
+    Uniform3iv = (PFNUNIFORM3IVPROC)IntGetProcAddress("glUniform3iv");
+    Uniform3iv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4iv(GLint location, GLsizei count, const GLint *value)
+  {
+    Uniform4iv = (PFNUNIFORM4IVPROC)IntGetProcAddress("glUniform4iv");
+    Uniform4iv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix2fv = (PFNUNIFORMMATRIX2FVPROC)IntGetProcAddress("glUniformMatrix2fv");
+    UniformMatrix2fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix3fv = (PFNUNIFORMMATRIX3FVPROC)IntGetProcAddress("glUniformMatrix3fv");
+    UniformMatrix3fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix4fv = (PFNUNIFORMMATRIX4FVPROC)IntGetProcAddress("glUniformMatrix4fv");
+    UniformMatrix4fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ValidateProgram(GLuint program)
+  {
+    ValidateProgram = (PFNVALIDATEPROGRAMPROC)IntGetProcAddress("glValidateProgram");
+    ValidateProgram(program);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
+  {
+    VertexAttribPointer = (PFNVERTEXATTRIBPOINTERPROC)IntGetProcAddress("glVertexAttribPointer");
+    VertexAttribPointer(index, size, type, normalized, stride, pointer);
+  }
+
+
+  // Extension: 2.1
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix2x3fv = (PFNUNIFORMMATRIX2X3FVPROC)IntGetProcAddress("glUniformMatrix2x3fv");
+    UniformMatrix2x3fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix3x2fv = (PFNUNIFORMMATRIX3X2FVPROC)IntGetProcAddress("glUniformMatrix3x2fv");
+    UniformMatrix3x2fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix2x4fv = (PFNUNIFORMMATRIX2X4FVPROC)IntGetProcAddress("glUniformMatrix2x4fv");
+    UniformMatrix2x4fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix4x2fv = (PFNUNIFORMMATRIX4X2FVPROC)IntGetProcAddress("glUniformMatrix4x2fv");
+    UniformMatrix4x2fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix3x4fv = (PFNUNIFORMMATRIX3X4FVPROC)IntGetProcAddress("glUniformMatrix3x4fv");
+    UniformMatrix3x4fv(location, count, transpose, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+  {
+    UniformMatrix4x3fv = (PFNUNIFORMMATRIX4X3FVPROC)IntGetProcAddress("glUniformMatrix4x3fv");
+    UniformMatrix4x3fv(location, count, transpose, value);
+  }
+
+
+  // Extension: ARB_vertex_array_object
+  static void CODEGEN_FUNCPTR Switch_BindVertexArray(GLuint ren_array)
+  {
+    BindVertexArray = (PFNBINDVERTEXARRAYPROC)IntGetProcAddress("glBindVertexArray");
+    BindVertexArray(ren_array);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteVertexArrays(GLsizei n, const GLuint *arrays)
+  {
+    DeleteVertexArrays = (PFNDELETEVERTEXARRAYSPROC)IntGetProcAddress("glDeleteVertexArrays");
+    DeleteVertexArrays(n, arrays);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenVertexArrays(GLsizei n, GLuint *arrays)
+  {
+    GenVertexArrays = (PFNGENVERTEXARRAYSPROC)IntGetProcAddress("glGenVertexArrays");
+    GenVertexArrays(n, arrays);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsVertexArray(GLuint ren_array)
+  {
+    IsVertexArray = (PFNISVERTEXARRAYPROC)IntGetProcAddress("glIsVertexArray");
+    return IsVertexArray(ren_array);
+  }
+
+
+  // Extension: ARB_map_buffer_range
+  static GLvoid* CODEGEN_FUNCPTR Switch_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
+  {
+    MapBufferRange = (PFNMAPBUFFERRANGEPROC)IntGetProcAddress("glMapBufferRange");
+    return MapBufferRange(target, offset, length, access);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+  {
+    FlushMappedBufferRange = (PFNFLUSHMAPPEDBUFFERRANGEPROC)IntGetProcAddress("glFlushMappedBufferRange");
+    FlushMappedBufferRange(target, offset, length);
+  }
+
+
+  // Extension: ARB_framebuffer_object
+  static GLboolean CODEGEN_FUNCPTR Switch_IsRenderbuffer(GLuint renderbuffer)
+  {
+    IsRenderbuffer = (PFNISRENDERBUFFERPROC)IntGetProcAddress("glIsRenderbuffer");
+    return IsRenderbuffer(renderbuffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindRenderbuffer(GLenum target, GLuint renderbuffer)
+  {
+    BindRenderbuffer = (PFNBINDRENDERBUFFERPROC)IntGetProcAddress("glBindRenderbuffer");
+    BindRenderbuffer(target, renderbuffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
+  {
+    DeleteRenderbuffers = (PFNDELETERENDERBUFFERSPROC)IntGetProcAddress("glDeleteRenderbuffers");
+    DeleteRenderbuffers(n, renderbuffers);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
+  {
+    GenRenderbuffers = (PFNGENRENDERBUFFERSPROC)IntGetProcAddress("glGenRenderbuffers");
+    GenRenderbuffers(n, renderbuffers);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+  {
+    RenderbufferStorage = (PFNRENDERBUFFERSTORAGEPROC)IntGetProcAddress("glRenderbufferStorage");
+    RenderbufferStorage(target, internalformat, width, height);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
+  {
+    GetRenderbufferParameteriv = (PFNGETRENDERBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetRenderbufferParameteriv");
+    GetRenderbufferParameteriv(target, pname, params);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsFramebuffer(GLuint framebuffer)
+  {
+    IsFramebuffer = (PFNISFRAMEBUFFERPROC)IntGetProcAddress("glIsFramebuffer");
+    return IsFramebuffer(framebuffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindFramebuffer(GLenum target, GLuint framebuffer)
+  {
+    BindFramebuffer = (PFNBINDFRAMEBUFFERPROC)IntGetProcAddress("glBindFramebuffer");
+    BindFramebuffer(target, framebuffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+  {
+    DeleteFramebuffers = (PFNDELETEFRAMEBUFFERSPROC)IntGetProcAddress("glDeleteFramebuffers");
+    DeleteFramebuffers(n, framebuffers);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenFramebuffers(GLsizei n, GLuint *framebuffers)
+  {
+    GenFramebuffers = (PFNGENFRAMEBUFFERSPROC)IntGetProcAddress("glGenFramebuffers");
+    GenFramebuffers(n, framebuffers);
+  }
+
+  static GLenum CODEGEN_FUNCPTR Switch_CheckFramebufferStatus(GLenum target)
+  {
+    CheckFramebufferStatus = (PFNCHECKFRAMEBUFFERSTATUSPROC)IntGetProcAddress("glCheckFramebufferStatus");
+    return CheckFramebufferStatus(target);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+  {
+    FramebufferTexture1D = (PFNFRAMEBUFFERTEXTURE1DPROC)IntGetProcAddress("glFramebufferTexture1D");
+    FramebufferTexture1D(target, attachment, textarget, texture, level);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+  {
+    FramebufferTexture2D = (PFNFRAMEBUFFERTEXTURE2DPROC)IntGetProcAddress("glFramebufferTexture2D");
+    FramebufferTexture2D(target, attachment, textarget, texture, level);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+  {
+    FramebufferTexture3D = (PFNFRAMEBUFFERTEXTURE3DPROC)IntGetProcAddress("glFramebufferTexture3D");
+    FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+  {
+    FramebufferRenderbuffer = (PFNFRAMEBUFFERRENDERBUFFERPROC)IntGetProcAddress("glFramebufferRenderbuffer");
+    FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
+  {
+    GetFramebufferAttachmentParameteriv = (PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)IntGetProcAddress("glGetFramebufferAttachmentParameteriv");
+    GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GenerateMipmap(GLenum target)
+  {
+    GenerateMipmap = (PFNGENERATEMIPMAPPROC)IntGetProcAddress("glGenerateMipmap");
+    GenerateMipmap(target);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+  {
+    BlitFramebuffer = (PFNBLITFRAMEBUFFERPROC)IntGetProcAddress("glBlitFramebuffer");
+    BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+  {
+    RenderbufferStorageMultisample = (PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)IntGetProcAddress("glRenderbufferStorageMultisample");
+    RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
+  {
+    FramebufferTextureLayer = (PFNFRAMEBUFFERTEXTURELAYERPROC)IntGetProcAddress("glFramebufferTextureLayer");
+    FramebufferTextureLayer(target, attachment, texture, level, layer);
+  }
+
+
+  // Extension: 3.0
+  static void CODEGEN_FUNCPTR Switch_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+  {
+    ColorMaski = (PFNCOLORMASKIPROC)IntGetProcAddress("glColorMaski");
+    ColorMaski(index, r, g, b, a);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
+  {
+    GetBooleani_v = (PFNGETBOOLEANI_VPROC)IntGetProcAddress("glGetBooleani_v");
+    GetBooleani_v(target, index, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetIntegeri_v(GLenum target, GLuint index, GLint *data)
+  {
+    GetIntegeri_v = (PFNGETINTEGERI_VPROC)IntGetProcAddress("glGetIntegeri_v");
+    GetIntegeri_v(target, index, data);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Enablei(GLenum target, GLuint index)
+  {
+    Enablei = (PFNENABLEIPROC)IntGetProcAddress("glEnablei");
+    Enablei(target, index);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Disablei(GLenum target, GLuint index)
+  {
+    Disablei = (PFNDISABLEIPROC)IntGetProcAddress("glDisablei");
+    Disablei(target, index);
+  }
+
+  static GLboolean CODEGEN_FUNCPTR Switch_IsEnabledi(GLenum target, GLuint index)
+  {
+    IsEnabledi = (PFNISENABLEDIPROC)IntGetProcAddress("glIsEnabledi");
+    return IsEnabledi(target, index);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BeginTransformFeedback(GLenum primitiveMode)
+  {
+    BeginTransformFeedback = (PFNBEGINTRANSFORMFEEDBACKPROC)IntGetProcAddress("glBeginTransformFeedback");
+    BeginTransformFeedback(primitiveMode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_EndTransformFeedback()
+  {
+    EndTransformFeedback = (PFNENDTRANSFORMFEEDBACKPROC)IntGetProcAddress("glEndTransformFeedback");
+    EndTransformFeedback();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+  {
+    BindBufferRange = (PFNBINDBUFFERRANGEPROC)IntGetProcAddress("glBindBufferRange");
+    BindBufferRange(target, index, buffer, offset, size);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
+  {
+    BindBufferBase = (PFNBINDBUFFERBASEPROC)IntGetProcAddress("glBindBufferBase");
+    BindBufferBase(target, index, buffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
+  {
+    TransformFeedbackVaryings = (PFNTRANSFORMFEEDBACKVARYINGSPROC)IntGetProcAddress("glTransformFeedbackVaryings");
+    TransformFeedbackVaryings(program, count, varyings, bufferMode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
+  {
+    GetTransformFeedbackVarying = (PFNGETTRANSFORMFEEDBACKVARYINGPROC)IntGetProcAddress("glGetTransformFeedbackVarying");
+    GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClampColor(GLenum target, GLenum clamp)
+  {
+    ClampColor = (PFNCLAMPCOLORPROC)IntGetProcAddress("glClampColor");
+    ClampColor(target, clamp);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BeginConditionalRender(GLuint id, GLenum mode)
+  {
+    BeginConditionalRender = (PFNBEGINCONDITIONALRENDERPROC)IntGetProcAddress("glBeginConditionalRender");
+    BeginConditionalRender(id, mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_EndConditionalRender()
+  {
+    EndConditionalRender = (PFNENDCONDITIONALRENDERPROC)IntGetProcAddress("glEndConditionalRender");
+    EndConditionalRender();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+  {
+    VertexAttribIPointer = (PFNVERTEXATTRIBIPOINTERPROC)IntGetProcAddress("glVertexAttribIPointer");
+    VertexAttribIPointer(index, size, type, stride, pointer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
+  {
+    GetVertexAttribIiv = (PFNGETVERTEXATTRIBIIVPROC)IntGetProcAddress("glGetVertexAttribIiv");
+    GetVertexAttribIiv(index, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
+  {
+    GetVertexAttribIuiv = (PFNGETVERTEXATTRIBIUIVPROC)IntGetProcAddress("glGetVertexAttribIuiv");
+    GetVertexAttribIuiv(index, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI1i(GLuint index, GLint x)
+  {
+    VertexAttribI1i = (PFNVERTEXATTRIBI1IPROC)IntGetProcAddress("glVertexAttribI1i");
+    VertexAttribI1i(index, x);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI2i(GLuint index, GLint x, GLint y)
+  {
+    VertexAttribI2i = (PFNVERTEXATTRIBI2IPROC)IntGetProcAddress("glVertexAttribI2i");
+    VertexAttribI2i(index, x, y);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
+  {
+    VertexAttribI3i = (PFNVERTEXATTRIBI3IPROC)IntGetProcAddress("glVertexAttribI3i");
+    VertexAttribI3i(index, x, y, z);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
+  {
+    VertexAttribI4i = (PFNVERTEXATTRIBI4IPROC)IntGetProcAddress("glVertexAttribI4i");
+    VertexAttribI4i(index, x, y, z, w);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI1ui(GLuint index, GLuint x)
+  {
+    VertexAttribI1ui = (PFNVERTEXATTRIBI1UIPROC)IntGetProcAddress("glVertexAttribI1ui");
+    VertexAttribI1ui(index, x);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
+  {
+    VertexAttribI2ui = (PFNVERTEXATTRIBI2UIPROC)IntGetProcAddress("glVertexAttribI2ui");
+    VertexAttribI2ui(index, x, y);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
+  {
+    VertexAttribI3ui = (PFNVERTEXATTRIBI3UIPROC)IntGetProcAddress("glVertexAttribI3ui");
+    VertexAttribI3ui(index, x, y, z);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+  {
+    VertexAttribI4ui = (PFNVERTEXATTRIBI4UIPROC)IntGetProcAddress("glVertexAttribI4ui");
+    VertexAttribI4ui(index, x, y, z, w);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI1iv(GLuint index, const GLint *v)
+  {
+    VertexAttribI1iv = (PFNVERTEXATTRIBI1IVPROC)IntGetProcAddress("glVertexAttribI1iv");
+    VertexAttribI1iv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI2iv(GLuint index, const GLint *v)
+  {
+    VertexAttribI2iv = (PFNVERTEXATTRIBI2IVPROC)IntGetProcAddress("glVertexAttribI2iv");
+    VertexAttribI2iv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI3iv(GLuint index, const GLint *v)
+  {
+    VertexAttribI3iv = (PFNVERTEXATTRIBI3IVPROC)IntGetProcAddress("glVertexAttribI3iv");
+    VertexAttribI3iv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4iv(GLuint index, const GLint *v)
+  {
+    VertexAttribI4iv = (PFNVERTEXATTRIBI4IVPROC)IntGetProcAddress("glVertexAttribI4iv");
+    VertexAttribI4iv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI1uiv(GLuint index, const GLuint *v)
+  {
+    VertexAttribI1uiv = (PFNVERTEXATTRIBI1UIVPROC)IntGetProcAddress("glVertexAttribI1uiv");
+    VertexAttribI1uiv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI2uiv(GLuint index, const GLuint *v)
+  {
+    VertexAttribI2uiv = (PFNVERTEXATTRIBI2UIVPROC)IntGetProcAddress("glVertexAttribI2uiv");
+    VertexAttribI2uiv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI3uiv(GLuint index, const GLuint *v)
+  {
+    VertexAttribI3uiv = (PFNVERTEXATTRIBI3UIVPROC)IntGetProcAddress("glVertexAttribI3uiv");
+    VertexAttribI3uiv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4uiv(GLuint index, const GLuint *v)
+  {
+    VertexAttribI4uiv = (PFNVERTEXATTRIBI4UIVPROC)IntGetProcAddress("glVertexAttribI4uiv");
+    VertexAttribI4uiv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4bv(GLuint index, const GLbyte *v)
+  {
+    VertexAttribI4bv = (PFNVERTEXATTRIBI4BVPROC)IntGetProcAddress("glVertexAttribI4bv");
+    VertexAttribI4bv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4sv(GLuint index, const GLshort *v)
+  {
+    VertexAttribI4sv = (PFNVERTEXATTRIBI4SVPROC)IntGetProcAddress("glVertexAttribI4sv");
+    VertexAttribI4sv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4ubv(GLuint index, const GLubyte *v)
+  {
+    VertexAttribI4ubv = (PFNVERTEXATTRIBI4UBVPROC)IntGetProcAddress("glVertexAttribI4ubv");
+    VertexAttribI4ubv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexAttribI4usv(GLuint index, const GLushort *v)
+  {
+    VertexAttribI4usv = (PFNVERTEXATTRIBI4USVPROC)IntGetProcAddress("glVertexAttribI4usv");
+    VertexAttribI4usv(index, v);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetUniformuiv(GLuint program, GLint location, GLuint *params)
+  {
+    GetUniformuiv = (PFNGETUNIFORMUIVPROC)IntGetProcAddress("glGetUniformuiv");
+    GetUniformuiv(program, location, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
+  {
+    BindFragDataLocation = (PFNBINDFRAGDATALOCATIONPROC)IntGetProcAddress("glBindFragDataLocation");
+    BindFragDataLocation(program, color, name);
+  }
+
+  static GLint CODEGEN_FUNCPTR Switch_GetFragDataLocation(GLuint program, const GLchar *name)
+  {
+    GetFragDataLocation = (PFNGETFRAGDATALOCATIONPROC)IntGetProcAddress("glGetFragDataLocation");
+    return GetFragDataLocation(program, name);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1ui(GLint location, GLuint v0)
+  {
+    Uniform1ui = (PFNUNIFORM1UIPROC)IntGetProcAddress("glUniform1ui");
+    Uniform1ui(location, v0);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2ui(GLint location, GLuint v0, GLuint v1)
+  {
+    Uniform2ui = (PFNUNIFORM2UIPROC)IntGetProcAddress("glUniform2ui");
+    Uniform2ui(location, v0, v1);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+  {
+    Uniform3ui = (PFNUNIFORM3UIPROC)IntGetProcAddress("glUniform3ui");
+    Uniform3ui(location, v0, v1, v2);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+  {
+    Uniform4ui = (PFNUNIFORM4UIPROC)IntGetProcAddress("glUniform4ui");
+    Uniform4ui(location, v0, v1, v2, v3);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
+  {
+    Uniform1uiv = (PFNUNIFORM1UIVPROC)IntGetProcAddress("glUniform1uiv");
+    Uniform1uiv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
+  {
+    Uniform2uiv = (PFNUNIFORM2UIVPROC)IntGetProcAddress("glUniform2uiv");
+    Uniform2uiv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
+  {
+    Uniform3uiv = (PFNUNIFORM3UIVPROC)IntGetProcAddress("glUniform3uiv");
+    Uniform3uiv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
+  {
+    Uniform4uiv = (PFNUNIFORM4UIVPROC)IntGetProcAddress("glUniform4uiv");
+    Uniform4uiv(location, count, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
+  {
+    TexParameterIiv = (PFNTEXPARAMETERIIVPROC)IntGetProcAddress("glTexParameterIiv");
+    TexParameterIiv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
+  {
+    TexParameterIuiv = (PFNTEXPARAMETERIUIVPROC)IntGetProcAddress("glTexParameterIuiv");
+    TexParameterIuiv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
+  {
+    GetTexParameterIiv = (PFNGETTEXPARAMETERIIVPROC)IntGetProcAddress("glGetTexParameterIiv");
+    GetTexParameterIiv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
+  {
+    GetTexParameterIuiv = (PFNGETTEXPARAMETERIUIVPROC)IntGetProcAddress("glGetTexParameterIuiv");
+    GetTexParameterIuiv(target, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
+  {
+    ClearBufferiv = (PFNCLEARBUFFERIVPROC)IntGetProcAddress("glClearBufferiv");
+    ClearBufferiv(buffer, drawbuffer, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
+  {
+    ClearBufferuiv = (PFNCLEARBUFFERUIVPROC)IntGetProcAddress("glClearBufferuiv");
+    ClearBufferuiv(buffer, drawbuffer, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
+  {
+    ClearBufferfv = (PFNCLEARBUFFERFVPROC)IntGetProcAddress("glClearBufferfv");
+    ClearBufferfv(buffer, drawbuffer, value);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+  {
+    ClearBufferfi = (PFNCLEARBUFFERFIPROC)IntGetProcAddress("glClearBufferfi");
+    ClearBufferfi(buffer, drawbuffer, depth, stencil);
+  }
+
+  static const GLubyte * CODEGEN_FUNCPTR Switch_GetStringi(GLenum name, GLuint index)
+  {
+    GetStringi = (PFNGETSTRINGIPROC)IntGetProcAddress("glGetStringi");
+    return GetStringi(name, index);
+  }
+
+
+  // Extension: ARB_uniform_buffer_object
+  static void CODEGEN_FUNCPTR Switch_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
+  {
+    GetUniformIndices = (PFNGETUNIFORMINDICESPROC)IntGetProcAddress("glGetUniformIndices");
+    GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
+  {
+    GetActiveUniformsiv = (PFNGETACTIVEUNIFORMSIVPROC)IntGetProcAddress("glGetActiveUniformsiv");
+    GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
+  {
+    GetActiveUniformName = (PFNGETACTIVEUNIFORMNAMEPROC)IntGetProcAddress("glGetActiveUniformName");
+    GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+  }
+
+  static GLuint CODEGEN_FUNCPTR Switch_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
+  {
+    GetUniformBlockIndex = (PFNGETUNIFORMBLOCKINDEXPROC)IntGetProcAddress("glGetUniformBlockIndex");
+    return GetUniformBlockIndex(program, uniformBlockName);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
+  {
+    GetActiveUniformBlockiv = (PFNGETACTIVEUNIFORMBLOCKIVPROC)IntGetProcAddress("glGetActiveUniformBlockiv");
+    GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+  {
+    GetActiveUniformBlockName = (PFNGETACTIVEUNIFORMBLOCKNAMEPROC)IntGetProcAddress("glGetActiveUniformBlockName");
+    GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+  {
+    UniformBlockBinding = (PFNUNIFORMBLOCKBINDINGPROC)IntGetProcAddress("glUniformBlockBinding");
+    UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+  }
+
+
+  // Extension: ARB_copy_buffer
+  static void CODEGEN_FUNCPTR Switch_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+  {
+    CopyBufferSubData = (PFNCOPYBUFFERSUBDATAPROC)IntGetProcAddress("glCopyBufferSubData");
+    CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+  }
+
+
+  // Extension: 3.1
+  static void CODEGEN_FUNCPTR Switch_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
+  {
+    DrawArraysInstanced = (PFNDRAWARRAYSINSTANCEDPROC)IntGetProcAddress("glDrawArraysInstanced");
+    DrawArraysInstanced(mode, first, count, instancecount);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
+  {
+    DrawElementsInstanced = (PFNDRAWELEMENTSINSTANCEDPROC)IntGetProcAddress("glDrawElementsInstanced");
+    DrawElementsInstanced(mode, count, type, indices, instancecount);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
+  {
+    TexBuffer = (PFNTEXBUFFERPROC)IntGetProcAddress("glTexBuffer");
+    TexBuffer(target, internalformat, buffer);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_PrimitiveRestartIndex(GLuint index)
+  {
+    PrimitiveRestartIndex = (PFNPRIMITIVERESTARTINDEXPROC)IntGetProcAddress("glPrimitiveRestartIndex");
+    PrimitiveRestartIndex(index);
+  }
+
+  // Legacy
+  static void CODEGEN_FUNCPTR Switch_EnableClientState(GLenum cap)
+  {
+    EnableClientState = (PFNENABLECLIENTSTATEPROC)IntGetProcAddress("glEnableClientState");
+    EnableClientState(cap);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_DisableClientState(GLenum cap)
+  {
+    DisableClientState = (PFNDISABLECLIENTSTATEPROC)IntGetProcAddress("glDisableClientState");
+    DisableClientState(cap);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+  {
+    VertexPointer = (PFNVERTEXPOINTERPROC)IntGetProcAddress("glVertexPointer");
+    VertexPointer(size, type, stride, ptr);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+  {
+    NormalPointer = (PFNNORMALPOINTERPROC)IntGetProcAddress("glNormalPointer");
+    NormalPointer(type, stride, ptr);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+  {
+    ColorPointer = (PFNCOLORPOINTERPROC)IntGetProcAddress("glColorPointer");
+    ColorPointer(size, type, stride, ptr);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+  {
+    TexCoordPointer = (PFNTEXCOORDPOINTERPROC)IntGetProcAddress("glTexCoordPointer");
+    TexCoordPointer(size, type, stride, ptr);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_TexEnvi(GLenum target, GLenum pname, GLint param)
+  {
+    TexEnvi = (PFNTEXENVIPROC)IntGetProcAddress("glTexEnvi");
+    TexEnvi(target, pname, param);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_MatrixMode(GLenum mode)
+  {
+    MatrixMode = (PFNMATRIXMODEPROC)IntGetProcAddress("glMatrixMode");
+    MatrixMode(mode);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_LoadIdentity(void)
+  {
+    LoadIdentity = (PFNLOADIDENTITYPROC)IntGetProcAddress("glLoadIdentity");
+    LoadIdentity();
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)
+  {
+    Ortho = (PFNORTHOPROC)IntGetProcAddress("glOrtho");
+    Ortho(left, right, bottom, top, near_val, far_val);
+  }
+
+  static void CODEGEN_FUNCPTR Switch_Color3d(GLdouble red, GLdouble green, GLdouble blue)
+  {
+    Color3d = (PFNCOLOR3DPROC)IntGetProcAddress("glColor3d");
+    Color3d(red, green, blue);
+  }
+
+
+
+  namespace
+  {
+    struct InitializeVariables
+    {
+      InitializeVariables()
+      {
+        // Extension: 1.1
+        CullFace = Switch_CullFace;
+        FrontFace = Switch_FrontFace;
+        Hint = Switch_Hint;
+        LineWidth = Switch_LineWidth;
+        PointSize = Switch_PointSize;
+        PolygonMode = Switch_PolygonMode;
+        Scissor = Switch_Scissor;
+        TexParameterf = Switch_TexParameterf;
+        TexParameterfv = Switch_TexParameterfv;
+        TexParameteri = Switch_TexParameteri;
+        TexParameteriv = Switch_TexParameteriv;
+        TexImage1D = Switch_TexImage1D;
+        TexImage2D = Switch_TexImage2D;
+        DrawBuffer = Switch_DrawBuffer;
+        Clear = Switch_Clear;
+        ClearColor = Switch_ClearColor;
+        ClearStencil = Switch_ClearStencil;
+        ClearDepth = Switch_ClearDepth;
+        StencilMask = Switch_StencilMask;
+        ColorMask = Switch_ColorMask;
+        DepthMask = Switch_DepthMask;
+        Disable = Switch_Disable;
+        Enable = Switch_Enable;
+        Finish = Switch_Finish;
+        Flush = Switch_Flush;
+        BlendFunc = Switch_BlendFunc;
+        LogicOp = Switch_LogicOp;
+        StencilFunc = Switch_StencilFunc;
+        StencilOp = Switch_StencilOp;
+        DepthFunc = Switch_DepthFunc;
+        PixelStoref = Switch_PixelStoref;
+        PixelStorei = Switch_PixelStorei;
+        ReadBuffer = Switch_ReadBuffer;
+        ReadPixels = Switch_ReadPixels;
+        GetBooleanv = Switch_GetBooleanv;
+        GetDoublev = Switch_GetDoublev;
+        GetError = Switch_GetError;
+        GetFloatv = Switch_GetFloatv;
+        GetIntegerv = Switch_GetIntegerv;
+        GetString = Switch_GetString;
+        GetTexImage = Switch_GetTexImage;
+        GetTexParameterfv = Switch_GetTexParameterfv;
+        GetTexParameteriv = Switch_GetTexParameteriv;
+        GetTexLevelParameterfv = Switch_GetTexLevelParameterfv;
+        GetTexLevelParameteriv = Switch_GetTexLevelParameteriv;
+        IsEnabled = Switch_IsEnabled;
+        DepthRange = Switch_DepthRange;
+        Viewport = Switch_Viewport;
+        DrawArrays = Switch_DrawArrays;
+        DrawElements = Switch_DrawElements;
+        GetPointerv = Switch_GetPointerv;
+        PolygonOffset = Switch_PolygonOffset;
+        CopyTexImage1D = Switch_CopyTexImage1D;
+        CopyTexImage2D = Switch_CopyTexImage2D;
+        CopyTexSubImage1D = Switch_CopyTexSubImage1D;
+        CopyTexSubImage2D = Switch_CopyTexSubImage2D;
+        TexSubImage1D = Switch_TexSubImage1D;
+        TexSubImage2D = Switch_TexSubImage2D;
+        BindTexture = Switch_BindTexture;
+        DeleteTextures = Switch_DeleteTextures;
+        GenTextures = Switch_GenTextures;
+        IsTexture = Switch_IsTexture;
+        Indexub = Switch_Indexub;
+        Indexubv = Switch_Indexubv;
+
+        // Extension: 1.2
+        BlendColor = Switch_BlendColor;
+        BlendEquation = Switch_BlendEquation;
+        DrawRangeElements = Switch_DrawRangeElements;
+        TexSubImage3D = Switch_TexSubImage3D;
+        CopyTexSubImage3D = Switch_CopyTexSubImage3D;
+
+        // Extension: 1.3
+        ActiveTexture = Switch_ActiveTexture;
+        SampleCoverage = Switch_SampleCoverage;
+        CompressedTexImage3D = Switch_CompressedTexImage3D;
+        CompressedTexImage2D = Switch_CompressedTexImage2D;
+        CompressedTexImage1D = Switch_CompressedTexImage1D;
+        CompressedTexSubImage3D = Switch_CompressedTexSubImage3D;
+        CompressedTexSubImage2D = Switch_CompressedTexSubImage2D;
+        CompressedTexSubImage1D = Switch_CompressedTexSubImage1D;
+        GetCompressedTexImage = Switch_GetCompressedTexImage;
+
+        // Extension: 1.4
+        BlendFuncSeparate = Switch_BlendFuncSeparate;
+        MultiDrawArrays = Switch_MultiDrawArrays;
+        MultiDrawElements = Switch_MultiDrawElements;
+        PointParameterf = Switch_PointParameterf;
+        PointParameterfv = Switch_PointParameterfv;
+        PointParameteri = Switch_PointParameteri;
+        PointParameteriv = Switch_PointParameteriv;
+
+        // Extension: 1.5
+        GenQueries = Switch_GenQueries;
+        DeleteQueries = Switch_DeleteQueries;
+        IsQuery = Switch_IsQuery;
+        BeginQuery = Switch_BeginQuery;
+        EndQuery = Switch_EndQuery;
+        GetQueryiv = Switch_GetQueryiv;
+        GetQueryObjectiv = Switch_GetQueryObjectiv;
+        GetQueryObjectuiv = Switch_GetQueryObjectuiv;
+        BindBuffer = Switch_BindBuffer;
+        DeleteBuffers = Switch_DeleteBuffers;
+        GenBuffers = Switch_GenBuffers;
+        IsBuffer = Switch_IsBuffer;
+        BufferData = Switch_BufferData;
+        BufferSubData = Switch_BufferSubData;
+        GetBufferSubData = Switch_GetBufferSubData;
+        MapBuffer = Switch_MapBuffer;
+        UnmapBuffer = Switch_UnmapBuffer;
+        GetBufferParameteriv = Switch_GetBufferParameteriv;
+        GetBufferPointerv = Switch_GetBufferPointerv;
+
+        // Extension: 2.0
+        BlendEquationSeparate = Switch_BlendEquationSeparate;
+        DrawBuffers = Switch_DrawBuffers;
+        StencilOpSeparate = Switch_StencilOpSeparate;
+        StencilFuncSeparate = Switch_StencilFuncSeparate;
+        StencilMaskSeparate = Switch_StencilMaskSeparate;
+        AttachShader = Switch_AttachShader;
+        BindAttribLocation = Switch_BindAttribLocation;
+        CompileShader = Switch_CompileShader;
+        CreateProgram = Switch_CreateProgram;
+        CreateShader = Switch_CreateShader;
+        DeleteProgram = Switch_DeleteProgram;
+        DeleteShader = Switch_DeleteShader;
+        DetachShader = Switch_DetachShader;
+        DisableVertexAttribArray = Switch_DisableVertexAttribArray;
+        EnableVertexAttribArray = Switch_EnableVertexAttribArray;
+        GetActiveAttrib = Switch_GetActiveAttrib;
+        GetActiveUniform = Switch_GetActiveUniform;
+        GetAttachedShaders = Switch_GetAttachedShaders;
+        GetAttribLocation = Switch_GetAttribLocation;
+        GetProgramiv = Switch_GetProgramiv;
+        GetProgramInfoLog = Switch_GetProgramInfoLog;
+        GetShaderiv = Switch_GetShaderiv;
+        GetShaderInfoLog = Switch_GetShaderInfoLog;
+        GetShaderSource = Switch_GetShaderSource;
+        GetUniformLocation = Switch_GetUniformLocation;
+        GetUniformfv = Switch_GetUniformfv;
+        GetUniformiv = Switch_GetUniformiv;
+        GetVertexAttribdv = Switch_GetVertexAttribdv;
+        GetVertexAttribfv = Switch_GetVertexAttribfv;
+        GetVertexAttribiv = Switch_GetVertexAttribiv;
+        GetVertexAttribPointerv = Switch_GetVertexAttribPointerv;
+        IsProgram = Switch_IsProgram;
+        IsShader = Switch_IsShader;
+        LinkProgram = Switch_LinkProgram;
+        ShaderSource = Switch_ShaderSource;
+        UseProgram = Switch_UseProgram;
+        Uniform1f = Switch_Uniform1f;
+        Uniform2f = Switch_Uniform2f;
+        Uniform3f = Switch_Uniform3f;
+        Uniform4f = Switch_Uniform4f;
+        Uniform1i = Switch_Uniform1i;
+        Uniform2i = Switch_Uniform2i;
+        Uniform3i = Switch_Uniform3i;
+        Uniform4i = Switch_Uniform4i;
+        Uniform1fv = Switch_Uniform1fv;
+        Uniform2fv = Switch_Uniform2fv;
+        Uniform3fv = Switch_Uniform3fv;
+        Uniform4fv = Switch_Uniform4fv;
+        Uniform1iv = Switch_Uniform1iv;
+        Uniform2iv = Switch_Uniform2iv;
+        Uniform3iv = Switch_Uniform3iv;
+        Uniform4iv = Switch_Uniform4iv;
+        UniformMatrix2fv = Switch_UniformMatrix2fv;
+        UniformMatrix3fv = Switch_UniformMatrix3fv;
+        UniformMatrix4fv = Switch_UniformMatrix4fv;
+        ValidateProgram = Switch_ValidateProgram;
+        VertexAttribPointer = Switch_VertexAttribPointer;
+
+        // Extension: 2.1
+        UniformMatrix2x3fv = Switch_UniformMatrix2x3fv;
+        UniformMatrix3x2fv = Switch_UniformMatrix3x2fv;
+        UniformMatrix2x4fv = Switch_UniformMatrix2x4fv;
+        UniformMatrix4x2fv = Switch_UniformMatrix4x2fv;
+        UniformMatrix3x4fv = Switch_UniformMatrix3x4fv;
+        UniformMatrix4x3fv = Switch_UniformMatrix4x3fv;
+
+        // Extension: ARB_vertex_array_object
+        BindVertexArray = Switch_BindVertexArray;
+        DeleteVertexArrays = Switch_DeleteVertexArrays;
+        GenVertexArrays = Switch_GenVertexArrays;
+        IsVertexArray = Switch_IsVertexArray;
+
+        // Extension: ARB_map_buffer_range
+        MapBufferRange = Switch_MapBufferRange;
+        FlushMappedBufferRange = Switch_FlushMappedBufferRange;
+
+        // Extension: ARB_framebuffer_object
+        IsRenderbuffer = Switch_IsRenderbuffer;
+        BindRenderbuffer = Switch_BindRenderbuffer;
+        DeleteRenderbuffers = Switch_DeleteRenderbuffers;
+        GenRenderbuffers = Switch_GenRenderbuffers;
+        RenderbufferStorage = Switch_RenderbufferStorage;
+        GetRenderbufferParameteriv = Switch_GetRenderbufferParameteriv;
+        IsFramebuffer = Switch_IsFramebuffer;
+        BindFramebuffer = Switch_BindFramebuffer;
+        DeleteFramebuffers = Switch_DeleteFramebuffers;
+        GenFramebuffers = Switch_GenFramebuffers;
+        CheckFramebufferStatus = Switch_CheckFramebufferStatus;
+        FramebufferTexture1D = Switch_FramebufferTexture1D;
+        FramebufferTexture2D = Switch_FramebufferTexture2D;
+        FramebufferTexture3D = Switch_FramebufferTexture3D;
+        FramebufferRenderbuffer = Switch_FramebufferRenderbuffer;
+        GetFramebufferAttachmentParameteriv = Switch_GetFramebufferAttachmentParameteriv;
+        GenerateMipmap = Switch_GenerateMipmap;
+        BlitFramebuffer = Switch_BlitFramebuffer;
+        RenderbufferStorageMultisample = Switch_RenderbufferStorageMultisample;
+        FramebufferTextureLayer = Switch_FramebufferTextureLayer;
+
+        // Extension: 3.0
+        ColorMaski = Switch_ColorMaski;
+        GetBooleani_v = Switch_GetBooleani_v;
+        GetIntegeri_v = Switch_GetIntegeri_v;
+        Enablei = Switch_Enablei;
+        Disablei = Switch_Disablei;
+        IsEnabledi = Switch_IsEnabledi;
+        BeginTransformFeedback = Switch_BeginTransformFeedback;
+        EndTransformFeedback = Switch_EndTransformFeedback;
+        BindBufferRange = Switch_BindBufferRange;
+        BindBufferBase = Switch_BindBufferBase;
+        TransformFeedbackVaryings = Switch_TransformFeedbackVaryings;
+        GetTransformFeedbackVarying = Switch_GetTransformFeedbackVarying;
+        ClampColor = Switch_ClampColor;
+        BeginConditionalRender = Switch_BeginConditionalRender;
+        EndConditionalRender = Switch_EndConditionalRender;
+        VertexAttribIPointer = Switch_VertexAttribIPointer;
+        GetVertexAttribIiv = Switch_GetVertexAttribIiv;
+        GetVertexAttribIuiv = Switch_GetVertexAttribIuiv;
+        VertexAttribI1i = Switch_VertexAttribI1i;
+        VertexAttribI2i = Switch_VertexAttribI2i;
+        VertexAttribI3i = Switch_VertexAttribI3i;
+        VertexAttribI4i = Switch_VertexAttribI4i;
+        VertexAttribI1ui = Switch_VertexAttribI1ui;
+        VertexAttribI2ui = Switch_VertexAttribI2ui;
+        VertexAttribI3ui = Switch_VertexAttribI3ui;
+        VertexAttribI4ui = Switch_VertexAttribI4ui;
+        VertexAttribI1iv = Switch_VertexAttribI1iv;
+        VertexAttribI2iv = Switch_VertexAttribI2iv;
+        VertexAttribI3iv = Switch_VertexAttribI3iv;
+        VertexAttribI4iv = Switch_VertexAttribI4iv;
+        VertexAttribI1uiv = Switch_VertexAttribI1uiv;
+        VertexAttribI2uiv = Switch_VertexAttribI2uiv;
+        VertexAttribI3uiv = Switch_VertexAttribI3uiv;
+        VertexAttribI4uiv = Switch_VertexAttribI4uiv;
+        VertexAttribI4bv = Switch_VertexAttribI4bv;
+        VertexAttribI4sv = Switch_VertexAttribI4sv;
+        VertexAttribI4ubv = Switch_VertexAttribI4ubv;
+        VertexAttribI4usv = Switch_VertexAttribI4usv;
+        GetUniformuiv = Switch_GetUniformuiv;
+        BindFragDataLocation = Switch_BindFragDataLocation;
+        GetFragDataLocation = Switch_GetFragDataLocation;
+        Uniform1ui = Switch_Uniform1ui;
+        Uniform2ui = Switch_Uniform2ui;
+        Uniform3ui = Switch_Uniform3ui;
+        Uniform4ui = Switch_Uniform4ui;
+        Uniform1uiv = Switch_Uniform1uiv;
+        Uniform2uiv = Switch_Uniform2uiv;
+        Uniform3uiv = Switch_Uniform3uiv;
+        Uniform4uiv = Switch_Uniform4uiv;
+        TexParameterIiv = Switch_TexParameterIiv;
+        TexParameterIuiv = Switch_TexParameterIuiv;
+        GetTexParameterIiv = Switch_GetTexParameterIiv;
+        GetTexParameterIuiv = Switch_GetTexParameterIuiv;
+        ClearBufferiv = Switch_ClearBufferiv;
+        ClearBufferuiv = Switch_ClearBufferuiv;
+        ClearBufferfv = Switch_ClearBufferfv;
+        ClearBufferfi = Switch_ClearBufferfi;
+        GetStringi = Switch_GetStringi;
+
+        // Extension: ARB_uniform_buffer_object
+        GetUniformIndices = Switch_GetUniformIndices;
+        GetActiveUniformsiv = Switch_GetActiveUniformsiv;
+        GetActiveUniformName = Switch_GetActiveUniformName;
+        GetUniformBlockIndex = Switch_GetUniformBlockIndex;
+        GetActiveUniformBlockiv = Switch_GetActiveUniformBlockiv;
+        GetActiveUniformBlockName = Switch_GetActiveUniformBlockName;
+        UniformBlockBinding = Switch_UniformBlockBinding;
+
+        // Extension: ARB_copy_buffer
+        CopyBufferSubData = Switch_CopyBufferSubData;
+
+        // Extension: 3.1
+        DrawArraysInstanced = Switch_DrawArraysInstanced;
+        DrawElementsInstanced = Switch_DrawElementsInstanced;
+        TexBuffer = Switch_TexBuffer;
+        PrimitiveRestartIndex = Switch_PrimitiveRestartIndex;
+
+        // Legacy
+        EnableClientState = Switch_EnableClientState;
+        DisableClientState = Switch_DisableClientState;
+        VertexPointer = Switch_VertexPointer;
+        NormalPointer = Switch_NormalPointer;
+        ColorPointer = Switch_ColorPointer;
+        TexCoordPointer = Switch_TexCoordPointer;
+
+        TexEnvi = Switch_TexEnvi;
+
+        MatrixMode = Switch_MatrixMode;
+        LoadIdentity = Switch_LoadIdentity;
+        Ortho = Switch_Ortho;
+
+        Color3d = Switch_Color3d;
+
+      }
+    };
+
+    InitializeVariables g_initVariables;
+  }
+
+  namespace sys
+  {
+    namespace
+    {
+      void ClearExtensionVariables()
+      {
+      }
+
+      struct MapEntry
+      {
+        const char *extName;
+        bool *extVariable;
+      };
+
+      struct MapCompare
+      {
+        MapCompare(const char *test_) : test(test_) {}
+        bool operator()(const MapEntry &other) { return strcmp(test, other.extName) == 0; }
+        const char *test;
+      };
+
+      struct ClearEntry
+      {
+        void operator()(MapEntry &entry) { *(entry.extVariable) = false;}
+      };
+
+      MapEntry g_mappingTable[1] =
+      {
+      };
+
+      void LoadExtByName(const char *extensionName)
+      {
+        MapEntry *tableEnd = &g_mappingTable[0];
+        MapEntry *entry = std::find_if(&g_mappingTable[0], tableEnd, MapCompare(extensionName));
+
+        if(entry != tableEnd)
+            *(entry->extVariable) = true;
+      }
+
+      void ProcExtsFromExtList()
+      {
+        GLint iLoop;
+        GLint iNumExtensions = 0;
+        GetIntegerv(NUM_EXTENSIONS, &iNumExtensions);
+
+        for(iLoop = 0; iLoop < iNumExtensions; iLoop++)
+        {
+            const char *strExtensionName = (const char *)GetStringi(EXTENSIONS, iLoop);
+            LoadExtByName(strExtensionName);
+        }
+      }
+    }
+    void CheckExtensions()
+    {
+      ClearExtensionVariables();
+      std::for_each(&g_mappingTable[0], &g_mappingTable[0], ClearEntry());
+
+      ProcExtsFromExtList();
+    }
+
+  }
+}
+
+#endif
diff --git a/modules/core/src/gl_core_3_1.hpp b/modules/core/src/gl_core_3_1.hpp
new file mode 100644
index 000000000..711ebe9ab
--- /dev/null
+++ b/modules/core/src/gl_core_3_1.hpp
@@ -0,0 +1,1342 @@
+#ifndef OPENGL_NOLOAD_STYLE_HPP
+#define OPENGL_NOLOAD_STYLE_HPP
+
+#if defined(__gl_h_) || defined(__GL_H__)
+#error Attempt to include auto-generated header after including gl.h
+#endif
+#if defined(__glext_h_) || defined(__GLEXT_H_)
+#error Attempt to include auto-generated header after including glext.h
+#endif
+#if defined(__gl_ATI_h_)
+#error Attempt to include auto-generated header after including glATI.h
+#endif
+
+#define __gl_h_
+#define __GL_H__
+#define __glext_h_
+#define __GLEXT_H_
+#define __gl_ATI_h_
+
+#ifndef APIENTRY
+    #if defined(__MINGW32__)
+        #ifndef WIN32_LEAN_AND_MEAN
+            #define WIN32_LEAN_AND_MEAN 1
+        #endif
+        #ifndef NOMINMAX
+            #define NOMINMAX
+        #endif
+        #include <windows.h>
+    #elif (defined(_MSC_VER) && _MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__)
+        #ifndef WIN32_LEAN_AND_MEAN
+            #define WIN32_LEAN_AND_MEAN 1
+        #endif
+        #ifndef NOMINMAX
+            #define NOMINMAX
+        #endif
+        #include <windows.h>
+    #else
+        #define APIENTRY
+    #endif
+#endif /*APIENTRY*/
+
+#ifndef CODEGEN_FUNCPTR
+    #define CODEGEN_REMOVE_FUNCPTR
+    #if defined(_WIN32)
+        #define CODEGEN_FUNCPTR APIENTRY
+    #else
+        #define CODEGEN_FUNCPTR
+    #endif
+#endif /*CODEGEN_FUNCPTR*/
+
+#ifndef GLAPI
+    #define GLAPI extern
+#endif
+
+
+#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
+#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
+
+  typedef unsigned int GLenum;
+  typedef unsigned char GLboolean;
+  typedef unsigned int GLbitfield;
+  typedef signed char GLbyte;
+  typedef short GLshort;
+  typedef int GLint;
+  typedef int GLsizei;
+  typedef unsigned char GLubyte;
+  typedef unsigned short GLushort;
+  typedef unsigned int GLuint;
+  typedef float GLfloat;
+  typedef float GLclampf;
+  typedef double GLdouble;
+  typedef double GLclampd;
+  #define GLvoid void
+
+#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
+
+#include <stddef.h>
+#ifndef GL_VERSION_2_0
+  /* GL type for program/shader text */
+  typedef char GLchar;
+#endif
+#ifndef GL_VERSION_1_5
+  /* GL types for handling large vertex buffer objects */
+  typedef ptrdiff_t GLintptr;
+  typedef ptrdiff_t GLsizeiptr;
+#endif
+#ifndef GL_ARB_vertex_buffer_object
+  /* GL types for handling large vertex buffer objects */
+  typedef ptrdiff_t GLintptrARB;
+  typedef ptrdiff_t GLsizeiptrARB;
+#endif
+#ifndef GL_ARB_shader_objects
+  /* GL types for program/shader text and shader object handles */
+  typedef char GLcharARB;
+  typedef unsigned int GLhandleARB;
+#endif
+/* GL type for "half" precision (s10e5) float data in host memory */
+#ifndef GL_ARB_half_float_pixel
+  typedef unsigned short GLhalfARB;
+#endif
+#ifndef GL_NV_half_float
+  typedef unsigned short GLhalfNV;
+#endif
+#ifndef GLEXT_64_TYPES_DEFINED
+  /* This code block is duplicated in glxext.h, so must be protected */
+  #define GLEXT_64_TYPES_DEFINED
+  /* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+  /* (as used in the GL_EXT_timer_query extension). */
+  #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #include <inttypes.h>
+  #elif defined(__sun__) || defined(__digital__)
+    #include <inttypes.h>
+    #if defined(__STDC__)
+      #if defined(__arch64__) || defined(_LP64)
+        typedef long int int64_t;
+        typedef unsigned long int uint64_t;
+        #else
+        typedef long long int int64_t;
+        typedef unsigned long long int uint64_t;
+      #endif /* __arch64__ */
+    #endif /* __STDC__ */
+  #elif defined( __VMS ) || defined(__sgi)
+    #include <inttypes.h>
+  #elif defined(__SCO__) || defined(__USLC__)
+    #include <stdint.h>
+  #elif defined(__UNIXOS2__) || defined(__SOL64__)
+    typedef long int int32_t;
+    typedef long long int int64_t;
+    typedef unsigned long long int uint64_t;
+  #elif defined(_WIN32) && defined(__GNUC__)
+    #include <stdint.h>
+  #elif defined(_WIN32)
+    typedef __int32 int32_t;
+    typedef __int64 int64_t;
+    typedef unsigned __int64 uint64_t;
+    #else
+    /* Fallback if nothing above works */
+    #include <inttypes.h>
+  #endif
+#endif
+#ifndef GL_EXT_timer_query
+  typedef int64_t GLint64EXT;
+  typedef uint64_t GLuint64EXT;
+#endif
+#ifndef GL_ARB_sync
+  typedef int64_t GLint64;
+  typedef uint64_t GLuint64;
+  typedef struct __GLsync *GLsync;
+#endif
+#ifndef GL_ARB_cl_event
+  /* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */
+  struct _cl_context;
+  struct _cl_event;
+#endif
+#ifndef GL_ARB_debug_output
+  typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+#endif
+#ifndef GL_AMD_debug_output
+  typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+#endif
+#ifndef GL_KHR_debug
+  typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+#endif
+#ifndef GL_NV_vdpau_interop
+  typedef GLintptr GLvdpauSurfaceNV;
+#endif
+
+namespace gl
+{
+  /////////////////////////
+  // Extension Variables
+  namespace exts
+  {
+  }
+
+  enum
+  {
+    // Version: 1.1
+    DEPTH_BUFFER_BIT                 = 0x00000100,
+    STENCIL_BUFFER_BIT               = 0x00000400,
+    COLOR_BUFFER_BIT                 = 0x00004000,
+    FALSE_                           = 0,
+    TRUE_                            = 1,
+    POINTS                           = 0x0000,
+    LINES                            = 0x0001,
+    LINE_LOOP                        = 0x0002,
+    LINE_STRIP                       = 0x0003,
+    TRIANGLES                        = 0x0004,
+    TRIANGLE_STRIP                   = 0x0005,
+    TRIANGLE_FAN                     = 0x0006,
+    QUADS                            = 0x0007,
+    NEVER                            = 0x0200,
+    LESS                             = 0x0201,
+    EQUAL                            = 0x0202,
+    LEQUAL                           = 0x0203,
+    GREATER                          = 0x0204,
+    NOTEQUAL                         = 0x0205,
+    GEQUAL                           = 0x0206,
+    ALWAYS                           = 0x0207,
+    ZERO                             = 0,
+    ONE                              = 1,
+    SRC_COLOR                        = 0x0300,
+    ONE_MINUS_SRC_COLOR              = 0x0301,
+    SRC_ALPHA                        = 0x0302,
+    ONE_MINUS_SRC_ALPHA              = 0x0303,
+    DST_ALPHA                        = 0x0304,
+    ONE_MINUS_DST_ALPHA              = 0x0305,
+    DST_COLOR                        = 0x0306,
+    ONE_MINUS_DST_COLOR              = 0x0307,
+    SRC_ALPHA_SATURATE               = 0x0308,
+    NONE                             = 0,
+    FRONT_LEFT                       = 0x0400,
+    FRONT_RIGHT                      = 0x0401,
+    BACK_LEFT                        = 0x0402,
+    BACK_RIGHT                       = 0x0403,
+    FRONT                            = 0x0404,
+    BACK                             = 0x0405,
+    LEFT                             = 0x0406,
+    RIGHT                            = 0x0407,
+    FRONT_AND_BACK                   = 0x0408,
+    NO_ERROR_                        = 0,
+    INVALID_ENUM                     = 0x0500,
+    INVALID_VALUE                    = 0x0501,
+    INVALID_OPERATION                = 0x0502,
+    OUT_OF_MEMORY                    = 0x0505,
+    CW                               = 0x0900,
+    CCW                              = 0x0901,
+    POINT_SIZE                       = 0x0B11,
+    POINT_SIZE_RANGE                 = 0x0B12,
+    POINT_SIZE_GRANULARITY           = 0x0B13,
+    LINE_SMOOTH                      = 0x0B20,
+    LINE_WIDTH                       = 0x0B21,
+    LINE_WIDTH_RANGE                 = 0x0B22,
+    LINE_WIDTH_GRANULARITY           = 0x0B23,
+    POLYGON_MODE                     = 0x0B40,
+    POLYGON_SMOOTH                   = 0x0B41,
+    CULL_FACE                        = 0x0B44,
+    CULL_FACE_MODE                   = 0x0B45,
+    FRONT_FACE                       = 0x0B46,
+    DEPTH_RANGE                      = 0x0B70,
+    DEPTH_TEST                       = 0x0B71,
+    DEPTH_WRITEMASK                  = 0x0B72,
+    DEPTH_CLEAR_VALUE                = 0x0B73,
+    DEPTH_FUNC                       = 0x0B74,
+    STENCIL_TEST                     = 0x0B90,
+    STENCIL_CLEAR_VALUE              = 0x0B91,
+    STENCIL_FUNC                     = 0x0B92,
+    STENCIL_VALUE_MASK               = 0x0B93,
+    STENCIL_FAIL                     = 0x0B94,
+    STENCIL_PASS_DEPTH_FAIL          = 0x0B95,
+    STENCIL_PASS_DEPTH_PASS          = 0x0B96,
+    STENCIL_REF                      = 0x0B97,
+    STENCIL_WRITEMASK                = 0x0B98,
+    VIEWPORT                         = 0x0BA2,
+    DITHER                           = 0x0BD0,
+    BLEND_DST                        = 0x0BE0,
+    BLEND_SRC                        = 0x0BE1,
+    BLEND                            = 0x0BE2,
+    LOGIC_OP_MODE                    = 0x0BF0,
+    COLOR_LOGIC_OP                   = 0x0BF2,
+    DRAW_BUFFER                      = 0x0C01,
+    READ_BUFFER                      = 0x0C02,
+    SCISSOR_BOX                      = 0x0C10,
+    SCISSOR_TEST                     = 0x0C11,
+    COLOR_CLEAR_VALUE                = 0x0C22,
+    COLOR_WRITEMASK                  = 0x0C23,
+    DOUBLEBUFFER                     = 0x0C32,
+    STEREO                           = 0x0C33,
+    LINE_SMOOTH_HINT                 = 0x0C52,
+    POLYGON_SMOOTH_HINT              = 0x0C53,
+    UNPACK_SWAP_BYTES                = 0x0CF0,
+    UNPACK_LSB_FIRST                 = 0x0CF1,
+    UNPACK_ROW_LENGTH                = 0x0CF2,
+    UNPACK_SKIP_ROWS                 = 0x0CF3,
+    UNPACK_SKIP_PIXELS               = 0x0CF4,
+    UNPACK_ALIGNMENT                 = 0x0CF5,
+    PACK_SWAP_BYTES                  = 0x0D00,
+    PACK_LSB_FIRST                   = 0x0D01,
+    PACK_ROW_LENGTH                  = 0x0D02,
+    PACK_SKIP_ROWS                   = 0x0D03,
+    PACK_SKIP_PIXELS                 = 0x0D04,
+    PACK_ALIGNMENT                   = 0x0D05,
+    MAX_TEXTURE_SIZE                 = 0x0D33,
+    MAX_VIEWPORT_DIMS                = 0x0D3A,
+    SUBPIXEL_BITS                    = 0x0D50,
+    TEXTURE_1D                       = 0x0DE0,
+    TEXTURE_2D                       = 0x0DE1,
+    POLYGON_OFFSET_UNITS             = 0x2A00,
+    POLYGON_OFFSET_POINT             = 0x2A01,
+    POLYGON_OFFSET_LINE              = 0x2A02,
+    POLYGON_OFFSET_FILL              = 0x8037,
+    POLYGON_OFFSET_FACTOR            = 0x8038,
+    TEXTURE_BINDING_1D               = 0x8068,
+    TEXTURE_BINDING_2D               = 0x8069,
+    TEXTURE_WIDTH                    = 0x1000,
+    TEXTURE_HEIGHT                   = 0x1001,
+    TEXTURE_INTERNAL_FORMAT          = 0x1003,
+    TEXTURE_BORDER_COLOR             = 0x1004,
+    TEXTURE_RED_SIZE                 = 0x805C,
+    TEXTURE_GREEN_SIZE               = 0x805D,
+    TEXTURE_BLUE_SIZE                = 0x805E,
+    TEXTURE_ALPHA_SIZE               = 0x805F,
+    DONT_CARE                        = 0x1100,
+    FASTEST                          = 0x1101,
+    NICEST                           = 0x1102,
+    BYTE                             = 0x1400,
+    UNSIGNED_BYTE                    = 0x1401,
+    SHORT                            = 0x1402,
+    UNSIGNED_SHORT                   = 0x1403,
+    INT                              = 0x1404,
+    UNSIGNED_INT                     = 0x1405,
+    FLOAT                            = 0x1406,
+    DOUBLE                           = 0x140A,
+    CLEAR                            = 0x1500,
+    AND                              = 0x1501,
+    AND_REVERSE                      = 0x1502,
+    COPY                             = 0x1503,
+    AND_INVERTED                     = 0x1504,
+    NOOP                             = 0x1505,
+    XOR                              = 0x1506,
+    OR                               = 0x1507,
+    NOR                              = 0x1508,
+    EQUIV                            = 0x1509,
+    INVERT                           = 0x150A,
+    OR_REVERSE                       = 0x150B,
+    COPY_INVERTED                    = 0x150C,
+    OR_INVERTED                      = 0x150D,
+    NAND                             = 0x150E,
+    SET                              = 0x150F,
+    TEXTURE                          = 0x1702,
+    COLOR                            = 0x1800,
+    DEPTH                            = 0x1801,
+    STENCIL                          = 0x1802,
+    STENCIL_INDEX                    = 0x1901,
+    DEPTH_COMPONENT                  = 0x1902,
+    RED                              = 0x1903,
+    GREEN                            = 0x1904,
+    BLUE                             = 0x1905,
+    ALPHA                            = 0x1906,
+    RGB                              = 0x1907,
+    RGBA                             = 0x1908,
+    POINT                            = 0x1B00,
+    LINE                             = 0x1B01,
+    FILL                             = 0x1B02,
+    KEEP                             = 0x1E00,
+    REPLACE                          = 0x1E01,
+    INCR                             = 0x1E02,
+    DECR                             = 0x1E03,
+    VENDOR                           = 0x1F00,
+    RENDERER                         = 0x1F01,
+    VERSION_                         = 0x1F02,
+    EXTENSIONS                       = 0x1F03,
+    NEAREST                          = 0x2600,
+    LINEAR                           = 0x2601,
+    NEAREST_MIPMAP_NEAREST           = 0x2700,
+    LINEAR_MIPMAP_NEAREST            = 0x2701,
+    NEAREST_MIPMAP_LINEAR            = 0x2702,
+    LINEAR_MIPMAP_LINEAR             = 0x2703,
+    TEXTURE_MAG_FILTER               = 0x2800,
+    TEXTURE_MIN_FILTER               = 0x2801,
+    TEXTURE_WRAP_S                   = 0x2802,
+    TEXTURE_WRAP_T                   = 0x2803,
+    PROXY_TEXTURE_1D                 = 0x8063,
+    PROXY_TEXTURE_2D                 = 0x8064,
+    REPEAT                           = 0x2901,
+    R3_G3_B2                         = 0x2A10,
+    RGB4                             = 0x804F,
+    RGB5                             = 0x8050,
+    RGB8                             = 0x8051,
+    RGB10                            = 0x8052,
+    RGB12                            = 0x8053,
+    RGB16                            = 0x8054,
+    RGBA2                            = 0x8055,
+    RGBA4                            = 0x8056,
+    RGB5_A1                          = 0x8057,
+    RGBA8                            = 0x8058,
+    RGB10_A2                         = 0x8059,
+    RGBA12                           = 0x805A,
+    RGBA16                           = 0x805B,
+
+    // Core Extension: ARB_imaging
+    CONSTANT_COLOR                   = 0x8001,
+    ONE_MINUS_CONSTANT_COLOR         = 0x8002,
+    CONSTANT_ALPHA                   = 0x8003,
+    ONE_MINUS_CONSTANT_ALPHA         = 0x8004,
+    BLEND_COLOR                      = 0x8005,
+    FUNC_ADD                         = 0x8006,
+    MIN                              = 0x8007,
+    MAX                              = 0x8008,
+    BLEND_EQUATION                   = 0x8009,
+    FUNC_SUBTRACT                    = 0x800A,
+    FUNC_REVERSE_SUBTRACT            = 0x800B,
+    CONVOLUTION_1D                   = 0x8010,
+    CONVOLUTION_2D                   = 0x8011,
+    SEPARABLE_2D                     = 0x8012,
+    CONVOLUTION_BORDER_MODE          = 0x8013,
+    CONVOLUTION_FILTER_SCALE         = 0x8014,
+    CONVOLUTION_FILTER_BIAS          = 0x8015,
+    REDUCE                           = 0x8016,
+    CONVOLUTION_FORMAT               = 0x8017,
+    CONVOLUTION_WIDTH                = 0x8018,
+    CONVOLUTION_HEIGHT               = 0x8019,
+    MAX_CONVOLUTION_WIDTH            = 0x801A,
+    MAX_CONVOLUTION_HEIGHT           = 0x801B,
+    POST_CONVOLUTION_RED_SCALE       = 0x801C,
+    POST_CONVOLUTION_GREEN_SCALE     = 0x801D,
+    POST_CONVOLUTION_BLUE_SCALE      = 0x801E,
+    POST_CONVOLUTION_ALPHA_SCALE     = 0x801F,
+    POST_CONVOLUTION_RED_BIAS        = 0x8020,
+    POST_CONVOLUTION_GREEN_BIAS      = 0x8021,
+    POST_CONVOLUTION_BLUE_BIAS       = 0x8022,
+    POST_CONVOLUTION_ALPHA_BIAS      = 0x8023,
+    HISTOGRAM                        = 0x8024,
+    PROXY_HISTOGRAM                  = 0x8025,
+    HISTOGRAM_WIDTH                  = 0x8026,
+    HISTOGRAM_FORMAT                 = 0x8027,
+    HISTOGRAM_RED_SIZE               = 0x8028,
+    HISTOGRAM_GREEN_SIZE             = 0x8029,
+    HISTOGRAM_BLUE_SIZE              = 0x802A,
+    HISTOGRAM_ALPHA_SIZE             = 0x802B,
+    HISTOGRAM_LUMINANCE_SIZE         = 0x802C,
+    HISTOGRAM_SINK                   = 0x802D,
+    MINMAX                           = 0x802E,
+    MINMAX_FORMAT                    = 0x802F,
+    MINMAX_SINK                      = 0x8030,
+    TABLE_TOO_LARGE                  = 0x8031,
+    COLOR_MATRIX                     = 0x80B1,
+    COLOR_MATRIX_STACK_DEPTH         = 0x80B2,
+    MAX_COLOR_MATRIX_STACK_DEPTH     = 0x80B3,
+    POST_COLOR_MATRIX_RED_SCALE      = 0x80B4,
+    POST_COLOR_MATRIX_GREEN_SCALE    = 0x80B5,
+    POST_COLOR_MATRIX_BLUE_SCALE     = 0x80B6,
+    POST_COLOR_MATRIX_ALPHA_SCALE    = 0x80B7,
+    POST_COLOR_MATRIX_RED_BIAS       = 0x80B8,
+    POST_COLOR_MATRIX_GREEN_BIAS     = 0x80B9,
+    POST_COLOR_MATRIX_BLUE_BIAS      = 0x80BA,
+    POST_COLOR_MATRIX_ALPHA_BIAS     = 0x80BB,
+    COLOR_TABLE                      = 0x80D0,
+    POST_CONVOLUTION_COLOR_TABLE     = 0x80D1,
+    POST_COLOR_MATRIX_COLOR_TABLE    = 0x80D2,
+    PROXY_COLOR_TABLE                = 0x80D3,
+    PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+    PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+    COLOR_TABLE_SCALE                = 0x80D6,
+    COLOR_TABLE_BIAS                 = 0x80D7,
+    COLOR_TABLE_FORMAT               = 0x80D8,
+    COLOR_TABLE_WIDTH                = 0x80D9,
+    COLOR_TABLE_RED_SIZE             = 0x80DA,
+    COLOR_TABLE_GREEN_SIZE           = 0x80DB,
+    COLOR_TABLE_BLUE_SIZE            = 0x80DC,
+    COLOR_TABLE_ALPHA_SIZE           = 0x80DD,
+    COLOR_TABLE_LUMINANCE_SIZE       = 0x80DE,
+    COLOR_TABLE_INTENSITY_SIZE       = 0x80DF,
+    CONSTANT_BORDER                  = 0x8151,
+    REPLICATE_BORDER                 = 0x8153,
+    CONVOLUTION_BORDER_COLOR         = 0x8154,
+
+    // Version: 1.2
+    UNSIGNED_BYTE_3_3_2              = 0x8032,
+    UNSIGNED_SHORT_4_4_4_4           = 0x8033,
+    UNSIGNED_SHORT_5_5_5_1           = 0x8034,
+    UNSIGNED_INT_8_8_8_8             = 0x8035,
+    UNSIGNED_INT_10_10_10_2          = 0x8036,
+    TEXTURE_BINDING_3D               = 0x806A,
+    PACK_SKIP_IMAGES                 = 0x806B,
+    PACK_IMAGE_HEIGHT                = 0x806C,
+    UNPACK_SKIP_IMAGES               = 0x806D,
+    UNPACK_IMAGE_HEIGHT              = 0x806E,
+    TEXTURE_3D                       = 0x806F,
+    PROXY_TEXTURE_3D                 = 0x8070,
+    TEXTURE_DEPTH                    = 0x8071,
+    TEXTURE_WRAP_R                   = 0x8072,
+    MAX_3D_TEXTURE_SIZE              = 0x8073,
+    UNSIGNED_BYTE_2_3_3_REV          = 0x8362,
+    UNSIGNED_SHORT_5_6_5             = 0x8363,
+    UNSIGNED_SHORT_5_6_5_REV         = 0x8364,
+    UNSIGNED_SHORT_4_4_4_4_REV       = 0x8365,
+    UNSIGNED_SHORT_1_5_5_5_REV       = 0x8366,
+    UNSIGNED_INT_8_8_8_8_REV         = 0x8367,
+    UNSIGNED_INT_2_10_10_10_REV      = 0x8368,
+    BGR                              = 0x80E0,
+    BGRA                             = 0x80E1,
+    MAX_ELEMENTS_VERTICES            = 0x80E8,
+    MAX_ELEMENTS_INDICES             = 0x80E9,
+    CLAMP_TO_EDGE                    = 0x812F,
+    TEXTURE_MIN_LOD                  = 0x813A,
+    TEXTURE_MAX_LOD                  = 0x813B,
+    TEXTURE_BASE_LEVEL               = 0x813C,
+    TEXTURE_MAX_LEVEL                = 0x813D,
+    SMOOTH_POINT_SIZE_RANGE          = 0x0B12,
+    SMOOTH_POINT_SIZE_GRANULARITY    = 0x0B13,
+    SMOOTH_LINE_WIDTH_RANGE          = 0x0B22,
+    SMOOTH_LINE_WIDTH_GRANULARITY    = 0x0B23,
+    ALIASED_LINE_WIDTH_RANGE         = 0x846E,
+
+    // Version: 1.3
+    TEXTURE0                         = 0x84C0,
+    TEXTURE1                         = 0x84C1,
+    TEXTURE2                         = 0x84C2,
+    TEXTURE3                         = 0x84C3,
+    TEXTURE4                         = 0x84C4,
+    TEXTURE5                         = 0x84C5,
+    TEXTURE6                         = 0x84C6,
+    TEXTURE7                         = 0x84C7,
+    TEXTURE8                         = 0x84C8,
+    TEXTURE9                         = 0x84C9,
+    TEXTURE10                        = 0x84CA,
+    TEXTURE11                        = 0x84CB,
+    TEXTURE12                        = 0x84CC,
+    TEXTURE13                        = 0x84CD,
+    TEXTURE14                        = 0x84CE,
+    TEXTURE15                        = 0x84CF,
+    TEXTURE16                        = 0x84D0,
+    TEXTURE17                        = 0x84D1,
+    TEXTURE18                        = 0x84D2,
+    TEXTURE19                        = 0x84D3,
+    TEXTURE20                        = 0x84D4,
+    TEXTURE21                        = 0x84D5,
+    TEXTURE22                        = 0x84D6,
+    TEXTURE23                        = 0x84D7,
+    TEXTURE24                        = 0x84D8,
+    TEXTURE25                        = 0x84D9,
+    TEXTURE26                        = 0x84DA,
+    TEXTURE27                        = 0x84DB,
+    TEXTURE28                        = 0x84DC,
+    TEXTURE29                        = 0x84DD,
+    TEXTURE30                        = 0x84DE,
+    TEXTURE31                        = 0x84DF,
+    ACTIVE_TEXTURE                   = 0x84E0,
+    MULTISAMPLE                      = 0x809D,
+    SAMPLE_ALPHA_TO_COVERAGE         = 0x809E,
+    SAMPLE_ALPHA_TO_ONE              = 0x809F,
+    SAMPLE_COVERAGE                  = 0x80A0,
+    SAMPLE_BUFFERS                   = 0x80A8,
+    SAMPLES                          = 0x80A9,
+    SAMPLE_COVERAGE_VALUE            = 0x80AA,
+    SAMPLE_COVERAGE_INVERT           = 0x80AB,
+    TEXTURE_CUBE_MAP                 = 0x8513,
+    TEXTURE_BINDING_CUBE_MAP         = 0x8514,
+    TEXTURE_CUBE_MAP_POSITIVE_X      = 0x8515,
+    TEXTURE_CUBE_MAP_NEGATIVE_X      = 0x8516,
+    TEXTURE_CUBE_MAP_POSITIVE_Y      = 0x8517,
+    TEXTURE_CUBE_MAP_NEGATIVE_Y      = 0x8518,
+    TEXTURE_CUBE_MAP_POSITIVE_Z      = 0x8519,
+    TEXTURE_CUBE_MAP_NEGATIVE_Z      = 0x851A,
+    PROXY_TEXTURE_CUBE_MAP           = 0x851B,
+    MAX_CUBE_MAP_TEXTURE_SIZE        = 0x851C,
+    COMPRESSED_RGB                   = 0x84ED,
+    COMPRESSED_RGBA                  = 0x84EE,
+    TEXTURE_COMPRESSION_HINT         = 0x84EF,
+    TEXTURE_COMPRESSED_IMAGE_SIZE    = 0x86A0,
+    TEXTURE_COMPRESSED               = 0x86A1,
+    NUM_COMPRESSED_TEXTURE_FORMATS   = 0x86A2,
+    COMPRESSED_TEXTURE_FORMATS       = 0x86A3,
+    CLAMP_TO_BORDER                  = 0x812D,
+
+    // Version: 1.4
+    BLEND_DST_RGB                    = 0x80C8,
+    BLEND_SRC_RGB                    = 0x80C9,
+    BLEND_DST_ALPHA                  = 0x80CA,
+    BLEND_SRC_ALPHA                  = 0x80CB,
+    POINT_FADE_THRESHOLD_SIZE        = 0x8128,
+    DEPTH_COMPONENT16                = 0x81A5,
+    DEPTH_COMPONENT24                = 0x81A6,
+    DEPTH_COMPONENT32                = 0x81A7,
+    MIRRORED_REPEAT                  = 0x8370,
+    MAX_TEXTURE_LOD_BIAS             = 0x84FD,
+    TEXTURE_LOD_BIAS                 = 0x8501,
+    INCR_WRAP                        = 0x8507,
+    DECR_WRAP                        = 0x8508,
+    TEXTURE_DEPTH_SIZE               = 0x884A,
+    TEXTURE_COMPARE_MODE             = 0x884C,
+    TEXTURE_COMPARE_FUNC             = 0x884D,
+
+    // Version: 1.5
+    BUFFER_SIZE                      = 0x8764,
+    BUFFER_USAGE                     = 0x8765,
+    QUERY_COUNTER_BITS               = 0x8864,
+    CURRENT_QUERY                    = 0x8865,
+    QUERY_RESULT                     = 0x8866,
+    QUERY_RESULT_AVAILABLE           = 0x8867,
+    ARRAY_BUFFER                     = 0x8892,
+    ELEMENT_ARRAY_BUFFER             = 0x8893,
+    ARRAY_BUFFER_BINDING             = 0x8894,
+    ELEMENT_ARRAY_BUFFER_BINDING     = 0x8895,
+    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
+    READ_ONLY                        = 0x88B8,
+    WRITE_ONLY                       = 0x88B9,
+    READ_WRITE                       = 0x88BA,
+    BUFFER_ACCESS                    = 0x88BB,
+    BUFFER_MAPPED                    = 0x88BC,
+    BUFFER_MAP_POINTER               = 0x88BD,
+    STREAM_DRAW                      = 0x88E0,
+    STREAM_READ                      = 0x88E1,
+    STREAM_COPY                      = 0x88E2,
+    STATIC_DRAW                      = 0x88E4,
+    STATIC_READ                      = 0x88E5,
+    STATIC_COPY                      = 0x88E6,
+    DYNAMIC_DRAW                     = 0x88E8,
+    DYNAMIC_READ                     = 0x88E9,
+    DYNAMIC_COPY                     = 0x88EA,
+    SAMPLES_PASSED                   = 0x8914,
+    SRC1_ALPHA                       = 0x8589,
+
+    // Version: 2.0
+    BLEND_EQUATION_RGB               = 0x8009,
+    VERTEX_ATTRIB_ARRAY_ENABLED      = 0x8622,
+    VERTEX_ATTRIB_ARRAY_SIZE         = 0x8623,
+    VERTEX_ATTRIB_ARRAY_STRIDE       = 0x8624,
+    VERTEX_ATTRIB_ARRAY_TYPE         = 0x8625,
+    CURRENT_VERTEX_ATTRIB            = 0x8626,
+    VERTEX_PROGRAM_POINT_SIZE        = 0x8642,
+    VERTEX_ATTRIB_ARRAY_POINTER      = 0x8645,
+    STENCIL_BACK_FUNC                = 0x8800,
+    STENCIL_BACK_FAIL                = 0x8801,
+    STENCIL_BACK_PASS_DEPTH_FAIL     = 0x8802,
+    STENCIL_BACK_PASS_DEPTH_PASS     = 0x8803,
+    MAX_DRAW_BUFFERS                 = 0x8824,
+    DRAW_BUFFER0                     = 0x8825,
+    DRAW_BUFFER1                     = 0x8826,
+    DRAW_BUFFER2                     = 0x8827,
+    DRAW_BUFFER3                     = 0x8828,
+    DRAW_BUFFER4                     = 0x8829,
+    DRAW_BUFFER5                     = 0x882A,
+    DRAW_BUFFER6                     = 0x882B,
+    DRAW_BUFFER7                     = 0x882C,
+    DRAW_BUFFER8                     = 0x882D,
+    DRAW_BUFFER9                     = 0x882E,
+    DRAW_BUFFER10                    = 0x882F,
+    DRAW_BUFFER11                    = 0x8830,
+    DRAW_BUFFER12                    = 0x8831,
+    DRAW_BUFFER13                    = 0x8832,
+    DRAW_BUFFER14                    = 0x8833,
+    DRAW_BUFFER15                    = 0x8834,
+    BLEND_EQUATION_ALPHA             = 0x883D,
+    MAX_VERTEX_ATTRIBS               = 0x8869,
+    VERTEX_ATTRIB_ARRAY_NORMALIZED   = 0x886A,
+    MAX_TEXTURE_IMAGE_UNITS          = 0x8872,
+    FRAGMENT_SHADER                  = 0x8B30,
+    VERTEX_SHADER                    = 0x8B31,
+    MAX_FRAGMENT_UNIFORM_COMPONENTS  = 0x8B49,
+    MAX_VERTEX_UNIFORM_COMPONENTS    = 0x8B4A,
+    MAX_VARYING_FLOATS               = 0x8B4B,
+    MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C,
+    MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
+    SHADER_TYPE                      = 0x8B4F,
+    FLOAT_VEC2                       = 0x8B50,
+    FLOAT_VEC3                       = 0x8B51,
+    FLOAT_VEC4                       = 0x8B52,
+    INT_VEC2                         = 0x8B53,
+    INT_VEC3                         = 0x8B54,
+    INT_VEC4                         = 0x8B55,
+    BOOL                             = 0x8B56,
+    BOOL_VEC2                        = 0x8B57,
+    BOOL_VEC3                        = 0x8B58,
+    BOOL_VEC4                        = 0x8B59,
+    FLOAT_MAT2                       = 0x8B5A,
+    FLOAT_MAT3                       = 0x8B5B,
+    FLOAT_MAT4                       = 0x8B5C,
+    SAMPLER_1D                       = 0x8B5D,
+    SAMPLER_2D                       = 0x8B5E,
+    SAMPLER_3D                       = 0x8B5F,
+    SAMPLER_CUBE                     = 0x8B60,
+    SAMPLER_1D_SHADOW                = 0x8B61,
+    SAMPLER_2D_SHADOW                = 0x8B62,
+    DELETE_STATUS                    = 0x8B80,
+    COMPILE_STATUS                   = 0x8B81,
+    LINK_STATUS                      = 0x8B82,
+    VALIDATE_STATUS                  = 0x8B83,
+    INFO_LOG_LENGTH                  = 0x8B84,
+    ATTACHED_SHADERS                 = 0x8B85,
+    ACTIVE_UNIFORMS                  = 0x8B86,
+    ACTIVE_UNIFORM_MAX_LENGTH        = 0x8B87,
+    SHADER_SOURCE_LENGTH             = 0x8B88,
+    ACTIVE_ATTRIBUTES                = 0x8B89,
+    ACTIVE_ATTRIBUTE_MAX_LENGTH      = 0x8B8A,
+    FRAGMENT_SHADER_DERIVATIVE_HINT  = 0x8B8B,
+    SHADING_LANGUAGE_VERSION         = 0x8B8C,
+    CURRENT_PROGRAM                  = 0x8B8D,
+    POINT_SPRITE_COORD_ORIGIN        = 0x8CA0,
+    LOWER_LEFT                       = 0x8CA1,
+    UPPER_LEFT                       = 0x8CA2,
+    STENCIL_BACK_REF                 = 0x8CA3,
+    STENCIL_BACK_VALUE_MASK          = 0x8CA4,
+    STENCIL_BACK_WRITEMASK           = 0x8CA5,
+
+    // Version: 2.1
+    PIXEL_PACK_BUFFER                = 0x88EB,
+    PIXEL_UNPACK_BUFFER              = 0x88EC,
+    PIXEL_PACK_BUFFER_BINDING        = 0x88ED,
+    PIXEL_UNPACK_BUFFER_BINDING      = 0x88EF,
+    FLOAT_MAT2x3                     = 0x8B65,
+    FLOAT_MAT2x4                     = 0x8B66,
+    FLOAT_MAT3x2                     = 0x8B67,
+    FLOAT_MAT3x4                     = 0x8B68,
+    FLOAT_MAT4x2                     = 0x8B69,
+    FLOAT_MAT4x3                     = 0x8B6A,
+    SRGB                             = 0x8C40,
+    SRGB8                            = 0x8C41,
+    SRGB_ALPHA                       = 0x8C42,
+    SRGB8_ALPHA8                     = 0x8C43,
+    COMPRESSED_SRGB                  = 0x8C48,
+    COMPRESSED_SRGB_ALPHA            = 0x8C49,
+
+    // Core Extension: ARB_vertex_array_object
+    VERTEX_ARRAY_BINDING             = 0x85B5,
+
+    // Core Extension: ARB_texture_rg
+    RG                               = 0x8227,
+    RG_INTEGER                       = 0x8228,
+    R8                               = 0x8229,
+    R16                              = 0x822A,
+    RG8                              = 0x822B,
+    RG16                             = 0x822C,
+    R16F                             = 0x822D,
+    R32F                             = 0x822E,
+    RG16F                            = 0x822F,
+    RG32F                            = 0x8230,
+    R8I                              = 0x8231,
+    R8UI                             = 0x8232,
+    R16I                             = 0x8233,
+    R16UI                            = 0x8234,
+    R32I                             = 0x8235,
+    R32UI                            = 0x8236,
+    RG8I                             = 0x8237,
+    RG8UI                            = 0x8238,
+    RG16I                            = 0x8239,
+    RG16UI                           = 0x823A,
+    RG32I                            = 0x823B,
+    RG32UI                           = 0x823C,
+
+    // Core Extension: ARB_texture_compression_rgtc
+    COMPRESSED_RED_RGTC1             = 0x8DBB,
+    COMPRESSED_SIGNED_RED_RGTC1      = 0x8DBC,
+    COMPRESSED_RG_RGTC2              = 0x8DBD,
+    COMPRESSED_SIGNED_RG_RGTC2       = 0x8DBE,
+
+    // Core Extension: ARB_map_buffer_range
+    MAP_READ_BIT                     = 0x0001,
+    MAP_WRITE_BIT                    = 0x0002,
+    MAP_INVALIDATE_RANGE_BIT         = 0x0004,
+    MAP_INVALIDATE_BUFFER_BIT        = 0x0008,
+    MAP_FLUSH_EXPLICIT_BIT           = 0x0010,
+    MAP_UNSYNCHRONIZED_BIT           = 0x0020,
+
+    // Core Extension: ARB_half_float_vertex
+    HALF_FLOAT                       = 0x140B,
+
+    // Core Extension: ARB_framebuffer_sRGB
+    FRAMEBUFFER_SRGB                 = 0x8DB9,
+
+    // Core Extension: ARB_framebuffer_object
+    INVALID_FRAMEBUFFER_OPERATION    = 0x0506,
+    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210,
+    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211,
+    FRAMEBUFFER_ATTACHMENT_RED_SIZE  = 0x8212,
+    FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213,
+    FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214,
+    FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215,
+    FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216,
+    FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217,
+    FRAMEBUFFER_DEFAULT              = 0x8218,
+    FRAMEBUFFER_UNDEFINED            = 0x8219,
+    DEPTH_STENCIL_ATTACHMENT         = 0x821A,
+    INDEX                            = 0x8222,
+    MAX_RENDERBUFFER_SIZE            = 0x84E8,
+    DEPTH_STENCIL                    = 0x84F9,
+    UNSIGNED_INT_24_8                = 0x84FA,
+    DEPTH24_STENCIL8                 = 0x88F0,
+    TEXTURE_STENCIL_SIZE             = 0x88F1,
+    TEXTURE_RED_TYPE                 = 0x8C10,
+    TEXTURE_GREEN_TYPE               = 0x8C11,
+    TEXTURE_BLUE_TYPE                = 0x8C12,
+    TEXTURE_ALPHA_TYPE               = 0x8C13,
+    TEXTURE_DEPTH_TYPE               = 0x8C16,
+    UNSIGNED_NORMALIZED              = 0x8C17,
+    FRAMEBUFFER_BINDING              = 0x8CA6,
+    DRAW_FRAMEBUFFER_BINDING         = 0x8CA6,
+    RENDERBUFFER_BINDING             = 0x8CA7,
+    READ_FRAMEBUFFER                 = 0x8CA8,
+    DRAW_FRAMEBUFFER                 = 0x8CA9,
+    READ_FRAMEBUFFER_BINDING         = 0x8CAA,
+    RENDERBUFFER_SAMPLES             = 0x8CAB,
+    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0,
+    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3,
+    FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4,
+    FRAMEBUFFER_COMPLETE             = 0x8CD5,
+    FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6,
+    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7,
+    FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB,
+    FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC,
+    FRAMEBUFFER_UNSUPPORTED          = 0x8CDD,
+    MAX_COLOR_ATTACHMENTS            = 0x8CDF,
+    COLOR_ATTACHMENT0                = 0x8CE0,
+    COLOR_ATTACHMENT1                = 0x8CE1,
+    COLOR_ATTACHMENT2                = 0x8CE2,
+    COLOR_ATTACHMENT3                = 0x8CE3,
+    COLOR_ATTACHMENT4                = 0x8CE4,
+    COLOR_ATTACHMENT5                = 0x8CE5,
+    COLOR_ATTACHMENT6                = 0x8CE6,
+    COLOR_ATTACHMENT7                = 0x8CE7,
+    COLOR_ATTACHMENT8                = 0x8CE8,
+    COLOR_ATTACHMENT9                = 0x8CE9,
+    COLOR_ATTACHMENT10               = 0x8CEA,
+    COLOR_ATTACHMENT11               = 0x8CEB,
+    COLOR_ATTACHMENT12               = 0x8CEC,
+    COLOR_ATTACHMENT13               = 0x8CED,
+    COLOR_ATTACHMENT14               = 0x8CEE,
+    COLOR_ATTACHMENT15               = 0x8CEF,
+    DEPTH_ATTACHMENT                 = 0x8D00,
+    STENCIL_ATTACHMENT               = 0x8D20,
+    FRAMEBUFFER                      = 0x8D40,
+    RENDERBUFFER                     = 0x8D41,
+    RENDERBUFFER_WIDTH               = 0x8D42,
+    RENDERBUFFER_HEIGHT              = 0x8D43,
+    RENDERBUFFER_INTERNAL_FORMAT     = 0x8D44,
+    STENCIL_INDEX1                   = 0x8D46,
+    STENCIL_INDEX4                   = 0x8D47,
+    STENCIL_INDEX8                   = 0x8D48,
+    STENCIL_INDEX16                  = 0x8D49,
+    RENDERBUFFER_RED_SIZE            = 0x8D50,
+    RENDERBUFFER_GREEN_SIZE          = 0x8D51,
+    RENDERBUFFER_BLUE_SIZE           = 0x8D52,
+    RENDERBUFFER_ALPHA_SIZE          = 0x8D53,
+    RENDERBUFFER_DEPTH_SIZE          = 0x8D54,
+    RENDERBUFFER_STENCIL_SIZE        = 0x8D55,
+    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56,
+    MAX_SAMPLES                      = 0x8D57,
+    TEXTURE_LUMINANCE_TYPE           = 0x8C14,
+    TEXTURE_INTENSITY_TYPE           = 0x8C15,
+
+    // Core Extension: ARB_depth_buffer_float
+    DEPTH_COMPONENT32F               = 0x8CAC,
+    DEPTH32F_STENCIL8                = 0x8CAD,
+    FLOAT_32_UNSIGNED_INT_24_8_REV   = 0x8DAD,
+
+    // Version: 3.0
+    COMPARE_REF_TO_TEXTURE           = 0x884E,
+    CLIP_DISTANCE0                   = 0x3000,
+    CLIP_DISTANCE1                   = 0x3001,
+    CLIP_DISTANCE2                   = 0x3002,
+    CLIP_DISTANCE3                   = 0x3003,
+    CLIP_DISTANCE4                   = 0x3004,
+    CLIP_DISTANCE5                   = 0x3005,
+    CLIP_DISTANCE6                   = 0x3006,
+    CLIP_DISTANCE7                   = 0x3007,
+    MAX_CLIP_DISTANCES               = 0x0D32,
+    MAJOR_VERSION                    = 0x821B,
+    MINOR_VERSION                    = 0x821C,
+    NUM_EXTENSIONS                   = 0x821D,
+    CONTEXT_FLAGS                    = 0x821E,
+    COMPRESSED_RED                   = 0x8225,
+    COMPRESSED_RG                    = 0x8226,
+    CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001,
+    RGBA32F                          = 0x8814,
+    RGB32F                           = 0x8815,
+    RGBA16F                          = 0x881A,
+    RGB16F                           = 0x881B,
+    VERTEX_ATTRIB_ARRAY_INTEGER      = 0x88FD,
+    MAX_ARRAY_TEXTURE_LAYERS         = 0x88FF,
+    MIN_PROGRAM_TEXEL_OFFSET         = 0x8904,
+    MAX_PROGRAM_TEXEL_OFFSET         = 0x8905,
+    CLAMP_READ_COLOR                 = 0x891C,
+    FIXED_ONLY                       = 0x891D,
+    TEXTURE_1D_ARRAY                 = 0x8C18,
+    PROXY_TEXTURE_1D_ARRAY           = 0x8C19,
+    TEXTURE_2D_ARRAY                 = 0x8C1A,
+    PROXY_TEXTURE_2D_ARRAY           = 0x8C1B,
+    TEXTURE_BINDING_1D_ARRAY         = 0x8C1C,
+    TEXTURE_BINDING_2D_ARRAY         = 0x8C1D,
+    R11F_G11F_B10F                   = 0x8C3A,
+    UNSIGNED_INT_10F_11F_11F_REV     = 0x8C3B,
+    RGB9_E5                          = 0x8C3D,
+    UNSIGNED_INT_5_9_9_9_REV         = 0x8C3E,
+    TEXTURE_SHARED_SIZE              = 0x8C3F,
+    TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76,
+    TRANSFORM_FEEDBACK_BUFFER_MODE   = 0x8C7F,
+    MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80,
+    TRANSFORM_FEEDBACK_VARYINGS      = 0x8C83,
+    TRANSFORM_FEEDBACK_BUFFER_START  = 0x8C84,
+    TRANSFORM_FEEDBACK_BUFFER_SIZE   = 0x8C85,
+    PRIMITIVES_GENERATED             = 0x8C87,
+    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88,
+    RASTERIZER_DISCARD               = 0x8C89,
+    MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A,
+    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B,
+    INTERLEAVED_ATTRIBS              = 0x8C8C,
+    SEPARATE_ATTRIBS                 = 0x8C8D,
+    TRANSFORM_FEEDBACK_BUFFER        = 0x8C8E,
+    TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F,
+    RGBA32UI                         = 0x8D70,
+    RGB32UI                          = 0x8D71,
+    RGBA16UI                         = 0x8D76,
+    RGB16UI                          = 0x8D77,
+    RGBA8UI                          = 0x8D7C,
+    RGB8UI                           = 0x8D7D,
+    RGBA32I                          = 0x8D82,
+    RGB32I                           = 0x8D83,
+    RGBA16I                          = 0x8D88,
+    RGB16I                           = 0x8D89,
+    RGBA8I                           = 0x8D8E,
+    RGB8I                            = 0x8D8F,
+    RED_INTEGER                      = 0x8D94,
+    GREEN_INTEGER                    = 0x8D95,
+    BLUE_INTEGER                     = 0x8D96,
+    RGB_INTEGER                      = 0x8D98,
+    RGBA_INTEGER                     = 0x8D99,
+    BGR_INTEGER                      = 0x8D9A,
+    BGRA_INTEGER                     = 0x8D9B,
+    SAMPLER_1D_ARRAY                 = 0x8DC0,
+    SAMPLER_2D_ARRAY                 = 0x8DC1,
+    SAMPLER_1D_ARRAY_SHADOW          = 0x8DC3,
+    SAMPLER_2D_ARRAY_SHADOW          = 0x8DC4,
+    SAMPLER_CUBE_SHADOW              = 0x8DC5,
+    UNSIGNED_INT_VEC2                = 0x8DC6,
+    UNSIGNED_INT_VEC3                = 0x8DC7,
+    UNSIGNED_INT_VEC4                = 0x8DC8,
+    INT_SAMPLER_1D                   = 0x8DC9,
+    INT_SAMPLER_2D                   = 0x8DCA,
+    INT_SAMPLER_3D                   = 0x8DCB,
+    INT_SAMPLER_CUBE                 = 0x8DCC,
+    INT_SAMPLER_1D_ARRAY             = 0x8DCE,
+    INT_SAMPLER_2D_ARRAY             = 0x8DCF,
+    UNSIGNED_INT_SAMPLER_1D          = 0x8DD1,
+    UNSIGNED_INT_SAMPLER_2D          = 0x8DD2,
+    UNSIGNED_INT_SAMPLER_3D          = 0x8DD3,
+    UNSIGNED_INT_SAMPLER_CUBE        = 0x8DD4,
+    UNSIGNED_INT_SAMPLER_1D_ARRAY    = 0x8DD6,
+    UNSIGNED_INT_SAMPLER_2D_ARRAY    = 0x8DD7,
+    QUERY_WAIT                       = 0x8E13,
+    QUERY_NO_WAIT                    = 0x8E14,
+    QUERY_BY_REGION_WAIT             = 0x8E15,
+    QUERY_BY_REGION_NO_WAIT          = 0x8E16,
+    BUFFER_ACCESS_FLAGS              = 0x911F,
+    BUFFER_MAP_LENGTH                = 0x9120,
+    BUFFER_MAP_OFFSET                = 0x9121,
+
+    // Core Extension: ARB_uniform_buffer_object
+    UNIFORM_BUFFER                   = 0x8A11,
+    UNIFORM_BUFFER_BINDING           = 0x8A28,
+    UNIFORM_BUFFER_START             = 0x8A29,
+    UNIFORM_BUFFER_SIZE              = 0x8A2A,
+    MAX_VERTEX_UNIFORM_BLOCKS        = 0x8A2B,
+    MAX_FRAGMENT_UNIFORM_BLOCKS      = 0x8A2D,
+    MAX_COMBINED_UNIFORM_BLOCKS      = 0x8A2E,
+    MAX_UNIFORM_BUFFER_BINDINGS      = 0x8A2F,
+    MAX_UNIFORM_BLOCK_SIZE           = 0x8A30,
+    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31,
+    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33,
+    UNIFORM_BUFFER_OFFSET_ALIGNMENT  = 0x8A34,
+    ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35,
+    ACTIVE_UNIFORM_BLOCKS            = 0x8A36,
+    UNIFORM_TYPE                     = 0x8A37,
+    UNIFORM_SIZE                     = 0x8A38,
+    UNIFORM_NAME_LENGTH              = 0x8A39,
+    UNIFORM_BLOCK_INDEX              = 0x8A3A,
+    UNIFORM_OFFSET                   = 0x8A3B,
+    UNIFORM_ARRAY_STRIDE             = 0x8A3C,
+    UNIFORM_MATRIX_STRIDE            = 0x8A3D,
+    UNIFORM_IS_ROW_MAJOR             = 0x8A3E,
+    UNIFORM_BLOCK_BINDING            = 0x8A3F,
+    UNIFORM_BLOCK_DATA_SIZE          = 0x8A40,
+    UNIFORM_BLOCK_NAME_LENGTH        = 0x8A41,
+    UNIFORM_BLOCK_ACTIVE_UNIFORMS    = 0x8A42,
+    UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43,
+    UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44,
+    UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46,
+    INVALID_INDEX                    = 0xFFFFFFFF,
+    MAX_GEOMETRY_UNIFORM_BLOCKS      = 0x8A2C,
+    MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32,
+    UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45,
+
+    // Core Extension: ARB_copy_buffer
+    COPY_READ_BUFFER                 = 0x8F36,
+    COPY_WRITE_BUFFER                = 0x8F37,
+    COPY_READ_BUFFER_BINDING         = 0x8F36,
+    COPY_WRITE_BUFFER_BINDING        = 0x8F37,
+
+    // Version: 3.1
+    SAMPLER_2D_RECT                  = 0x8B63,
+    SAMPLER_2D_RECT_SHADOW           = 0x8B64,
+    SAMPLER_BUFFER                   = 0x8DC2,
+    INT_SAMPLER_2D_RECT              = 0x8DCD,
+    INT_SAMPLER_BUFFER               = 0x8DD0,
+    UNSIGNED_INT_SAMPLER_2D_RECT     = 0x8DD5,
+    UNSIGNED_INT_SAMPLER_BUFFER      = 0x8DD8,
+    TEXTURE_BUFFER                   = 0x8C2A,
+    MAX_TEXTURE_BUFFER_SIZE          = 0x8C2B,
+    TEXTURE_BINDING_BUFFER           = 0x8C2C,
+    TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D,
+    TEXTURE_RECTANGLE                = 0x84F5,
+    TEXTURE_BINDING_RECTANGLE        = 0x84F6,
+    PROXY_TEXTURE_RECTANGLE          = 0x84F7,
+    MAX_RECTANGLE_TEXTURE_SIZE       = 0x84F8,
+    RED_SNORM                        = 0x8F90,
+    RG_SNORM                         = 0x8F91,
+    RGB_SNORM                        = 0x8F92,
+    RGBA_SNORM                       = 0x8F93,
+    R8_SNORM                         = 0x8F94,
+    RG8_SNORM                        = 0x8F95,
+    RGB8_SNORM                       = 0x8F96,
+    RGBA8_SNORM                      = 0x8F97,
+    R16_SNORM                        = 0x8F98,
+    RG16_SNORM                       = 0x8F99,
+    RGB16_SNORM                      = 0x8F9A,
+    RGBA16_SNORM                     = 0x8F9B,
+    SIGNED_NORMALIZED                = 0x8F9C,
+    PRIMITIVE_RESTART                = 0x8F9D,
+    PRIMITIVE_RESTART_INDEX          = 0x8F9E,
+
+  };
+
+  // Extension: 1.1
+  extern void (CODEGEN_FUNCPTR *CullFace)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *FrontFace)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *Hint)(GLenum target, GLenum mode);
+  extern void (CODEGEN_FUNCPTR *LineWidth)(GLfloat width);
+  extern void (CODEGEN_FUNCPTR *PointSize)(GLfloat size);
+  extern void (CODEGEN_FUNCPTR *PolygonMode)(GLenum face, GLenum mode);
+  extern void (CODEGEN_FUNCPTR *Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
+  extern void (CODEGEN_FUNCPTR *TexParameterf)(GLenum target, GLenum pname, GLfloat param);
+  extern void (CODEGEN_FUNCPTR *TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *TexParameteri)(GLenum target, GLenum pname, GLint param);
+  extern void (CODEGEN_FUNCPTR *TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
+  extern void (CODEGEN_FUNCPTR *TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *DrawBuffer)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *Clear)(GLbitfield mask);
+  extern void (CODEGEN_FUNCPTR *ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+  extern void (CODEGEN_FUNCPTR *ClearStencil)(GLint s);
+  extern void (CODEGEN_FUNCPTR *ClearDepth)(GLdouble depth);
+  extern void (CODEGEN_FUNCPTR *StencilMask)(GLuint mask);
+  extern void (CODEGEN_FUNCPTR *ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+  extern void (CODEGEN_FUNCPTR *DepthMask)(GLboolean flag);
+  extern void (CODEGEN_FUNCPTR *Disable)(GLenum cap);
+  extern void (CODEGEN_FUNCPTR *Enable)(GLenum cap);
+  extern void (CODEGEN_FUNCPTR *Finish)();
+  extern void (CODEGEN_FUNCPTR *Flush)();
+  extern void (CODEGEN_FUNCPTR *BlendFunc)(GLenum sfactor, GLenum dfactor);
+  extern void (CODEGEN_FUNCPTR *LogicOp)(GLenum opcode);
+  extern void (CODEGEN_FUNCPTR *StencilFunc)(GLenum func, GLint ref, GLuint mask);
+  extern void (CODEGEN_FUNCPTR *StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
+  extern void (CODEGEN_FUNCPTR *DepthFunc)(GLenum func);
+  extern void (CODEGEN_FUNCPTR *PixelStoref)(GLenum pname, GLfloat param);
+  extern void (CODEGEN_FUNCPTR *PixelStorei)(GLenum pname, GLint param);
+  extern void (CODEGEN_FUNCPTR *ReadBuffer)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *GetBooleanv)(GLenum pname, GLboolean *params);
+  extern void (CODEGEN_FUNCPTR *GetDoublev)(GLenum pname, GLdouble *params);
+  extern GLenum (CODEGEN_FUNCPTR *GetError)();
+  extern void (CODEGEN_FUNCPTR *GetFloatv)(GLenum pname, GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *GetIntegerv)(GLenum pname, GLint *params);
+  extern const GLubyte * (CODEGEN_FUNCPTR *GetString)(GLenum name);
+  extern void (CODEGEN_FUNCPTR *GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *GetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
+  extern GLboolean (CODEGEN_FUNCPTR *IsEnabled)(GLenum cap);
+  extern void (CODEGEN_FUNCPTR *DepthRange)(GLdouble ren_near, GLdouble ren_far);
+  extern void (CODEGEN_FUNCPTR *Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
+  extern void (CODEGEN_FUNCPTR *DrawArrays)(GLenum mode, GLint first, GLsizei count);
+  extern void (CODEGEN_FUNCPTR *DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+  extern void (CODEGEN_FUNCPTR *GetPointerv)(GLenum pname, GLvoid* *params);
+  extern void (CODEGEN_FUNCPTR *PolygonOffset)(GLfloat factor, GLfloat units);
+  extern void (CODEGEN_FUNCPTR *CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+  extern void (CODEGEN_FUNCPTR *CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+  extern void (CODEGEN_FUNCPTR *CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+  extern void (CODEGEN_FUNCPTR *CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+  extern void (CODEGEN_FUNCPTR *TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *BindTexture)(GLenum target, GLuint texture);
+  extern void (CODEGEN_FUNCPTR *DeleteTextures)(GLsizei n, const GLuint *textures);
+  extern void (CODEGEN_FUNCPTR *GenTextures)(GLsizei n, GLuint *textures);
+  extern GLboolean (CODEGEN_FUNCPTR *IsTexture)(GLuint texture);
+  extern void (CODEGEN_FUNCPTR *Indexub)(GLubyte c);
+  extern void (CODEGEN_FUNCPTR *Indexubv)(const GLubyte *c);
+
+  // Extension: 1.2
+  extern void (CODEGEN_FUNCPTR *BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+  extern void (CODEGEN_FUNCPTR *BlendEquation)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+  extern void (CODEGEN_FUNCPTR *TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+  extern void (CODEGEN_FUNCPTR *CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+
+  // Extension: 1.3
+  extern void (CODEGEN_FUNCPTR *ActiveTexture)(GLenum texture);
+  extern void (CODEGEN_FUNCPTR *SampleCoverage)(GLfloat value, GLboolean invert);
+  extern void (CODEGEN_FUNCPTR *CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img);
+
+  // Extension: 1.4
+  extern void (CODEGEN_FUNCPTR *BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+  extern void (CODEGEN_FUNCPTR *MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
+  extern void (CODEGEN_FUNCPTR *MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
+  extern void (CODEGEN_FUNCPTR *PointParameterf)(GLenum pname, GLfloat param);
+  extern void (CODEGEN_FUNCPTR *PointParameterfv)(GLenum pname, const GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *PointParameteri)(GLenum pname, GLint param);
+  extern void (CODEGEN_FUNCPTR *PointParameteriv)(GLenum pname, const GLint *params);
+
+  // Extension: 1.5
+  extern void (CODEGEN_FUNCPTR *GenQueries)(GLsizei n, GLuint *ids);
+  extern void (CODEGEN_FUNCPTR *DeleteQueries)(GLsizei n, const GLuint *ids);
+  extern GLboolean (CODEGEN_FUNCPTR *IsQuery)(GLuint id);
+  extern void (CODEGEN_FUNCPTR *BeginQuery)(GLenum target, GLuint id);
+  extern void (CODEGEN_FUNCPTR *EndQuery)(GLenum target);
+  extern void (CODEGEN_FUNCPTR *GetQueryiv)(GLenum target, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
+  extern void (CODEGEN_FUNCPTR *BindBuffer)(GLenum target, GLuint buffer);
+  extern void (CODEGEN_FUNCPTR *DeleteBuffers)(GLsizei n, const GLuint *buffers);
+  extern void (CODEGEN_FUNCPTR *GenBuffers)(GLsizei n, GLuint *buffers);
+  extern GLboolean (CODEGEN_FUNCPTR *IsBuffer)(GLuint buffer);
+  extern void (CODEGEN_FUNCPTR *BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+  extern void (CODEGEN_FUNCPTR *BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+  extern void (CODEGEN_FUNCPTR *GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
+  extern GLvoid* (CODEGEN_FUNCPTR *MapBuffer)(GLenum target, GLenum access);
+  extern GLboolean (CODEGEN_FUNCPTR *UnmapBuffer)(GLenum target);
+  extern void (CODEGEN_FUNCPTR *GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params);
+
+  // Extension: 2.0
+  extern void (CODEGEN_FUNCPTR *BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
+  extern void (CODEGEN_FUNCPTR *DrawBuffers)(GLsizei n, const GLenum *bufs);
+  extern void (CODEGEN_FUNCPTR *StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+  extern void (CODEGEN_FUNCPTR *StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
+  extern void (CODEGEN_FUNCPTR *StencilMaskSeparate)(GLenum face, GLuint mask);
+  extern void (CODEGEN_FUNCPTR *AttachShader)(GLuint program, GLuint shader);
+  extern void (CODEGEN_FUNCPTR *BindAttribLocation)(GLuint program, GLuint index, const GLchar *name);
+  extern void (CODEGEN_FUNCPTR *CompileShader)(GLuint shader);
+  extern GLuint (CODEGEN_FUNCPTR *CreateProgram)();
+  extern GLuint (CODEGEN_FUNCPTR *CreateShader)(GLenum type);
+  extern void (CODEGEN_FUNCPTR *DeleteProgram)(GLuint program);
+  extern void (CODEGEN_FUNCPTR *DeleteShader)(GLuint shader);
+  extern void (CODEGEN_FUNCPTR *DetachShader)(GLuint program, GLuint shader);
+  extern void (CODEGEN_FUNCPTR *DisableVertexAttribArray)(GLuint index);
+  extern void (CODEGEN_FUNCPTR *EnableVertexAttribArray)(GLuint index);
+  extern void (CODEGEN_FUNCPTR *GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+  extern void (CODEGEN_FUNCPTR *GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+  extern void (CODEGEN_FUNCPTR *GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
+  extern GLint (CODEGEN_FUNCPTR *GetAttribLocation)(GLuint program, const GLchar *name);
+  extern void (CODEGEN_FUNCPTR *GetProgramiv)(GLuint program, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+  extern void (CODEGEN_FUNCPTR *GetShaderiv)(GLuint shader, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+  extern void (CODEGEN_FUNCPTR *GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+  extern GLint (CODEGEN_FUNCPTR *GetUniformLocation)(GLuint program, const GLchar *name);
+  extern void (CODEGEN_FUNCPTR *GetUniformfv)(GLuint program, GLint location, GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *GetUniformiv)(GLuint program, GLint location, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer);
+  extern GLboolean (CODEGEN_FUNCPTR *IsProgram)(GLuint program);
+  extern GLboolean (CODEGEN_FUNCPTR *IsShader)(GLuint shader);
+  extern void (CODEGEN_FUNCPTR *LinkProgram)(GLuint program);
+  extern void (CODEGEN_FUNCPTR *ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
+  extern void (CODEGEN_FUNCPTR *UseProgram)(GLuint program);
+  extern void (CODEGEN_FUNCPTR *Uniform1f)(GLint location, GLfloat v0);
+  extern void (CODEGEN_FUNCPTR *Uniform2f)(GLint location, GLfloat v0, GLfloat v1);
+  extern void (CODEGEN_FUNCPTR *Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+  extern void (CODEGEN_FUNCPTR *Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+  extern void (CODEGEN_FUNCPTR *Uniform1i)(GLint location, GLint v0);
+  extern void (CODEGEN_FUNCPTR *Uniform2i)(GLint location, GLint v0, GLint v1);
+  extern void (CODEGEN_FUNCPTR *Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
+  extern void (CODEGEN_FUNCPTR *Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+  extern void (CODEGEN_FUNCPTR *Uniform1fv)(GLint location, GLsizei count, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *Uniform2fv)(GLint location, GLsizei count, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *Uniform3fv)(GLint location, GLsizei count, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *Uniform4fv)(GLint location, GLsizei count, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *Uniform1iv)(GLint location, GLsizei count, const GLint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform2iv)(GLint location, GLsizei count, const GLint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform3iv)(GLint location, GLsizei count, const GLint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform4iv)(GLint location, GLsizei count, const GLint *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *ValidateProgram)(GLuint program);
+  extern void (CODEGEN_FUNCPTR *VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+
+  // Extension: 2.1
+  extern void (CODEGEN_FUNCPTR *UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+
+  // Extension: ARB_vertex_array_object
+  extern void (CODEGEN_FUNCPTR *BindVertexArray)(GLuint ren_array);
+  extern void (CODEGEN_FUNCPTR *DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
+  extern void (CODEGEN_FUNCPTR *GenVertexArrays)(GLsizei n, GLuint *arrays);
+  extern GLboolean (CODEGEN_FUNCPTR *IsVertexArray)(GLuint ren_array);
+
+  // Extension: ARB_map_buffer_range
+  extern GLvoid* (CODEGEN_FUNCPTR *MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+  extern void (CODEGEN_FUNCPTR *FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
+
+  // Extension: ARB_framebuffer_object
+  extern GLboolean (CODEGEN_FUNCPTR *IsRenderbuffer)(GLuint renderbuffer);
+  extern void (CODEGEN_FUNCPTR *BindRenderbuffer)(GLenum target, GLuint renderbuffer);
+  extern void (CODEGEN_FUNCPTR *DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
+  extern void (CODEGEN_FUNCPTR *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
+  extern void (CODEGEN_FUNCPTR *RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+  extern void (CODEGEN_FUNCPTR *GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
+  extern GLboolean (CODEGEN_FUNCPTR *IsFramebuffer)(GLuint framebuffer);
+  extern void (CODEGEN_FUNCPTR *BindFramebuffer)(GLenum target, GLuint framebuffer);
+  extern void (CODEGEN_FUNCPTR *DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
+  extern void (CODEGEN_FUNCPTR *GenFramebuffers)(GLsizei n, GLuint *framebuffers);
+  extern GLenum (CODEGEN_FUNCPTR *CheckFramebufferStatus)(GLenum target);
+  extern void (CODEGEN_FUNCPTR *FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+  extern void (CODEGEN_FUNCPTR *FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+  extern void (CODEGEN_FUNCPTR *FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+  extern void (CODEGEN_FUNCPTR *FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+  extern void (CODEGEN_FUNCPTR *GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GenerateMipmap)(GLenum target);
+  extern void (CODEGEN_FUNCPTR *BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+  extern void (CODEGEN_FUNCPTR *RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+  extern void (CODEGEN_FUNCPTR *FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+
+  // Extension: 3.0
+  extern void (CODEGEN_FUNCPTR *ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+  extern void (CODEGEN_FUNCPTR *GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
+  extern void (CODEGEN_FUNCPTR *GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
+  extern void (CODEGEN_FUNCPTR *Enablei)(GLenum target, GLuint index);
+  extern void (CODEGEN_FUNCPTR *Disablei)(GLenum target, GLuint index);
+  extern GLboolean (CODEGEN_FUNCPTR *IsEnabledi)(GLenum target, GLuint index);
+  extern void (CODEGEN_FUNCPTR *BeginTransformFeedback)(GLenum primitiveMode);
+  extern void (CODEGEN_FUNCPTR *EndTransformFeedback)();
+  extern void (CODEGEN_FUNCPTR *BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+  extern void (CODEGEN_FUNCPTR *BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
+  extern void (CODEGEN_FUNCPTR *TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
+  extern void (CODEGEN_FUNCPTR *GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+  extern void (CODEGEN_FUNCPTR *ClampColor)(GLenum target, GLenum clamp);
+  extern void (CODEGEN_FUNCPTR *BeginConditionalRender)(GLuint id, GLenum mode);
+  extern void (CODEGEN_FUNCPTR *EndConditionalRender)();
+  extern void (CODEGEN_FUNCPTR *VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI1i)(GLuint index, GLint x);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI2i)(GLuint index, GLint x, GLint y);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI1ui)(GLuint index, GLuint x);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI1iv)(GLuint index, const GLint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI2iv)(GLuint index, const GLint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI3iv)(GLuint index, const GLint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4iv)(GLuint index, const GLint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI1uiv)(GLuint index, const GLuint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI2uiv)(GLuint index, const GLuint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI3uiv)(GLuint index, const GLuint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4uiv)(GLuint index, const GLuint *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4bv)(GLuint index, const GLbyte *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4sv)(GLuint index, const GLshort *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4ubv)(GLuint index, const GLubyte *v);
+  extern void (CODEGEN_FUNCPTR *VertexAttribI4usv)(GLuint index, const GLushort *v);
+  extern void (CODEGEN_FUNCPTR *GetUniformuiv)(GLuint program, GLint location, GLuint *params);
+  extern void (CODEGEN_FUNCPTR *BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name);
+  extern GLint (CODEGEN_FUNCPTR *GetFragDataLocation)(GLuint program, const GLchar *name);
+  extern void (CODEGEN_FUNCPTR *Uniform1ui)(GLint location, GLuint v0);
+  extern void (CODEGEN_FUNCPTR *Uniform2ui)(GLint location, GLuint v0, GLuint v1);
+  extern void (CODEGEN_FUNCPTR *Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+  extern void (CODEGEN_FUNCPTR *Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+  extern void (CODEGEN_FUNCPTR *Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
+  extern void (CODEGEN_FUNCPTR *Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
+  extern void (CODEGEN_FUNCPTR *TexParameterIiv)(GLenum target, GLenum pname, const GLint *params);
+  extern void (CODEGEN_FUNCPTR *TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params);
+  extern void (CODEGEN_FUNCPTR *GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params);
+  extern void (CODEGEN_FUNCPTR *ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
+  extern void (CODEGEN_FUNCPTR *ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
+  extern void (CODEGEN_FUNCPTR *ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+  extern void (CODEGEN_FUNCPTR *ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+  extern const GLubyte * (CODEGEN_FUNCPTR *GetStringi)(GLenum name, GLuint index);
+
+  // Extension: ARB_uniform_buffer_object
+  extern void (CODEGEN_FUNCPTR *GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
+  extern void (CODEGEN_FUNCPTR *GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+  extern GLuint (CODEGEN_FUNCPTR *GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
+  extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+  extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+  extern void (CODEGEN_FUNCPTR *UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+
+  // Extension: ARB_copy_buffer
+  extern void (CODEGEN_FUNCPTR *CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+
+  // Extension: 3.1
+  extern void (CODEGEN_FUNCPTR *DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+  extern void (CODEGEN_FUNCPTR *DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
+  extern void (CODEGEN_FUNCPTR *TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);
+  extern void (CODEGEN_FUNCPTR *PrimitiveRestartIndex)(GLuint index);
+
+  // Legacy
+  enum
+  {
+    VERTEX_ARRAY = 0x8074,
+    NORMAL_ARRAY = 0x8075,
+    COLOR_ARRAY = 0x8076,
+    TEXTURE_COORD_ARRAY = 0x8078,
+
+    TEXTURE_ENV = 0x2300,
+    TEXTURE_ENV_MODE = 0x2200,
+
+    MODELVIEW = 0x1700,
+    PROJECTION = 0x1701,
+    LIGHTING = 0x0B50
+  };
+
+  extern void (CODEGEN_FUNCPTR *EnableClientState)(GLenum cap);
+  extern void (CODEGEN_FUNCPTR *DisableClientState)(GLenum cap);
+  extern void (CODEGEN_FUNCPTR *VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+  extern void (CODEGEN_FUNCPTR *NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr);
+  extern void (CODEGEN_FUNCPTR *ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+  extern void (CODEGEN_FUNCPTR *TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+
+  extern void (CODEGEN_FUNCPTR *TexEnvi)(GLenum target, GLenum pname, GLint param);
+
+  extern void (CODEGEN_FUNCPTR *MatrixMode)(GLenum mode);
+  extern void (CODEGEN_FUNCPTR *LoadIdentity)(void);
+  extern void (CODEGEN_FUNCPTR *Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
+
+  extern void (CODEGEN_FUNCPTR *Color3d)(GLdouble red, GLdouble green, GLdouble blue);
+
+  namespace sys
+  {
+    void CheckExtensions();
+  }
+}
+#endif //OPENGL_NOLOAD_STYLE_HPP
diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp
index 42c287593..0776ca624 100644
--- a/modules/core/src/matrix.cpp
+++ b/modules/core/src/matrix.cpp
@@ -922,8 +922,8 @@ _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {}
 _InputArray::_InputArray(const vector<Mat>& vec) : flags(STD_VECTOR_MAT), obj((void*)&vec) {}
 _InputArray::_InputArray(const double& val) : flags(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F), obj((void*)&val), sz(Size(1,1)) {}
 _InputArray::_InputArray(const MatExpr& expr) : flags(FIXED_TYPE + FIXED_SIZE + EXPR), obj((void*)&expr) {}
-_InputArray::_InputArray(const GlBuffer& buf) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_BUFFER), obj((void*)&buf) {}
-_InputArray::_InputArray(const GlTexture& tex) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_TEXTURE), obj((void*)&tex) {}
+_InputArray::_InputArray(const GlBuffer& buf) : flags(OPENGL_BUFFER), obj((void*)&buf) {}
+_InputArray::_InputArray(const GlTexture2D &tex) : flags(OPENGL_TEXTURE2D), obj((void*)&tex) {}
 _InputArray::_InputArray(const gpu::GpuMat& d_mat) : flags(GPU_MAT), obj((void*)&d_mat) {}
 
 Mat _InputArray::getMat(int i) const
@@ -1076,14 +1076,14 @@ GlBuffer _InputArray::getGlBuffer() const
     }
 }
 
-GlTexture _InputArray::getGlTexture() const
+GlTexture2D _InputArray::getGlTexture2D() const
 {
     int k = kind();
 
-    CV_Assert(k == OPENGL_TEXTURE);
+    CV_Assert(k == OPENGL_TEXTURE2D);
     //if( k == OPENGL_TEXTURE )
     {
-        const GlTexture* tex = (const GlTexture*)obj;
+        const GlTexture2D* tex = (const GlTexture2D*)obj;
         return *tex;
     }
 }
@@ -1168,10 +1168,10 @@ Size _InputArray::size(int i) const
         return buf->size();
     }
 
-    if( k == OPENGL_TEXTURE )
+    if( k == OPENGL_TEXTURE2D )
     {
         CV_Assert( i < 0 );
-        const GlTexture* tex = (const GlTexture*)obj;
+        const GlTexture2D* tex = (const GlTexture2D*)obj;
         return tex->size();
     }
 
@@ -1216,9 +1216,6 @@ int _InputArray::type(int i) const
     if( k == OPENGL_BUFFER )
         return ((const GlBuffer*)obj)->type();
 
-    if( k == OPENGL_TEXTURE )
-        return ((const GlTexture*)obj)->type();
-
     CV_Assert( k == GPU_MAT );
     //if( k == GPU_MAT )
         return ((const gpu::GpuMat*)obj)->type();
@@ -1271,8 +1268,8 @@ bool _InputArray::empty() const
     if( k == OPENGL_BUFFER )
         return ((const GlBuffer*)obj)->empty();
 
-    if( k == OPENGL_TEXTURE )
-        return ((const GlTexture*)obj)->empty();
+    if( k == OPENGL_TEXTURE2D )
+        return ((const GlTexture2D*)obj)->empty();
 
     CV_Assert( k == GPU_MAT );
     //if( k == GPU_MAT )
@@ -1285,10 +1282,14 @@ _OutputArray::~_OutputArray() {}
 _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {}
 _OutputArray::_OutputArray(vector<Mat>& vec) : _InputArray(vec) {}
 _OutputArray::_OutputArray(gpu::GpuMat& d_mat) : _InputArray(d_mat) {}
+_OutputArray::_OutputArray(GlBuffer& buf) : _InputArray(buf) {}
+_OutputArray::_OutputArray(GlTexture2D& tex) : _InputArray(tex) {}
 
 _OutputArray::_OutputArray(const Mat& m) : _InputArray(m) {flags |= FIXED_SIZE|FIXED_TYPE;}
 _OutputArray::_OutputArray(const vector<Mat>& vec) : _InputArray(vec) {flags |= FIXED_SIZE;}
 _OutputArray::_OutputArray(const gpu::GpuMat& d_mat) : _InputArray(d_mat) {flags |= FIXED_SIZE|FIXED_TYPE;}
+_OutputArray::_OutputArray(const GlBuffer& buf) : _InputArray(buf) {flags |= FIXED_SIZE|FIXED_TYPE;}
+_OutputArray::_OutputArray(const GlTexture2D& tex) : _InputArray(tex) {flags |= FIXED_SIZE|FIXED_TYPE;}
 
 
 bool _OutputArray::fixedSize() const
@@ -1318,6 +1319,13 @@ void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int
         ((gpu::GpuMat*)obj)->create(_sz, mtype);
         return;
     }
+    if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 )
+    {
+        CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == _sz);
+        CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype);
+        ((GlBuffer*)obj)->create(_sz, mtype);
+        return;
+    }
     int sizes[] = {_sz.height, _sz.width};
     create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
@@ -1339,6 +1347,13 @@ void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransp
         ((gpu::GpuMat*)obj)->create(rows, cols, mtype);
         return;
     }
+    if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 )
+    {
+        CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == Size(cols, rows));
+        CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype);
+        ((GlBuffer*)obj)->create(rows, cols, mtype);
+        return;
+    }
     int sizes[] = {rows, cols};
     create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
 }
@@ -1558,6 +1573,18 @@ void _OutputArray::release() const
         return;
     }
 
+    if( k == OPENGL_BUFFER )
+    {
+        ((GlBuffer*)obj)->release();
+        return;
+    }
+
+    if( k == OPENGL_TEXTURE2D )
+    {
+        ((GlTexture2D*)obj)->release();
+        return;
+    }
+
     if( k == NONE )
         return;
 
@@ -1623,6 +1650,20 @@ gpu::GpuMat& _OutputArray::getGpuMatRef() const
     return *(gpu::GpuMat*)obj;
 }
 
+GlBuffer& _OutputArray::getGlBufferRef() const
+{
+    int k = kind();
+    CV_Assert( k == OPENGL_BUFFER );
+    return *(GlBuffer*)obj;
+}
+
+GlTexture2D& _OutputArray::getGlTexture2DRef() const
+{
+    int k = kind();
+    CV_Assert( k == OPENGL_TEXTURE2D );
+    return *(GlTexture2D*)obj;
+}
+
 static _OutputArray _none;
 OutputArray noArray() { return _none; }
 
diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index 12589b7ba..e3ac95fac 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -41,26 +41,11 @@
 //M*/
 
 #include "precomp.hpp"
-#include <iostream>
 #include "opencv2/core/opengl_interop.hpp"
 #include "opencv2/core/gpumat.hpp"
 
-#if defined WIN32 || defined _WIN32 || defined WINCE
-#include <windows.h>
-#undef small
-#undef min
-#undef max
-#undef abs
-#endif
-
 #ifdef HAVE_OPENGL
-    #ifdef __APPLE__
-        #include <OpenGL/gl.h>
-        #include <OpenGL/glu.h>
-    #else
-        #include <GL/gl.h>
-        #include <GL/glu.h>
-    #endif
+    #include "gl_core_3_1.hpp"
 
     #ifdef HAVE_CUDA
         #include <cuda_runtime.h>
@@ -72,213 +57,258 @@ using namespace std;
 using namespace cv;
 using namespace cv::gpu;
 
-#ifndef HAVE_OPENGL
-    #define throw_nogl CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support")
-    #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support")
-#else
-    #define throw_nogl CV_Error(CV_OpenGlNotSupported, "OpenGL context doesn't exist")
-
-    #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-        #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support")
+namespace
+{
+    #ifndef HAVE_CUDA
+        void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); }
     #else
+        void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); }
+
         #if defined(__GNUC__)
             #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
         #else /* defined(__CUDACC__) || defined(__MSVC__) */
             #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
         #endif
 
-        namespace
+        void ___cudaSafeCall(cudaError_t err, const char* file, const int line, const char* func = "")
         {
-            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);
-            }
+            if (cudaSuccess != err)
+                cv::gpu::error(cudaGetErrorString(err), file, line, func);
         }
-    #endif // HAVE_CUDA
-#endif
+    #endif
 
-namespace
+    #ifndef HAVE_OPENGL
+        void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); }
+    #else
+        void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); }
+    #endif
+}
+
+bool cv::checkGlError(const char* file, const int line, const char* func)
 {
-    class EmptyGlFuncTab : public CvOpenGlFuncTab
+#ifndef HAVE_OPENGL
+    (void) file;
+    (void) line;
+    (void) func;
+    return true;
+#else
+    GLenum err = gl::GetError();
+
+    if (err != gl::NO_ERROR_)
     {
-    public:
-        void genBuffers(int, unsigned int*) const { throw_nogl; }
-        void deleteBuffers(int, const unsigned int*) const { throw_nogl; }
+        const char* msg;
 
-        void bufferData(unsigned int, ptrdiff_t, const void*, unsigned int) const { throw_nogl; }
-        void bufferSubData(unsigned int, ptrdiff_t, ptrdiff_t, const void*) const { throw_nogl; }
+        switch (err)
+        {
+        case gl::INVALID_ENUM:
+            msg = "An unacceptable value is specified for an enumerated argument";
+            break;
 
-        void bindBuffer(unsigned int, unsigned int) const { throw_nogl; }
+        case gl::INVALID_VALUE:
+            msg = "A numeric argument is out of range";
+            break;
 
-        void* mapBuffer(unsigned int, unsigned int) const { throw_nogl; return 0; }
-        void unmapBuffer(unsigned int) const { throw_nogl; }
+        case gl::INVALID_OPERATION:
+            msg = "The specified operation is not allowed in the current state";
+            break;
 
-        void generateBitmapFont(const std::string&, int, int, bool, bool, int, int, int) const { throw_nogl; }
+        case gl::OUT_OF_MEMORY:
+            msg = "There is not enough memory left to execute the command";
+            break;
 
-        bool isGlContextInitialized() const { return false; }
-    };
+        default:
+            msg = "Unknown error";
+        };
 
-    const CvOpenGlFuncTab* g_glFuncTab = 0;
+        cvError(CV_OpenGlApiCallError, func, msg, file, line);
 
-#if defined HAVE_CUDA || defined HAVE_OPENGL
-    const CvOpenGlFuncTab* glFuncTab()
-    {
-        static EmptyGlFuncTab empty;
-        return g_glFuncTab ? g_glFuncTab : &empty;
+        return false;
     }
+
+    return true;
 #endif
 }
 
-CvOpenGlFuncTab::~CvOpenGlFuncTab()
-{
-    if (g_glFuncTab == this)
-        g_glFuncTab = 0;
-}
-
-void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab)
-{
-    g_glFuncTab = tab;
-}
-
 #ifdef HAVE_OPENGL
-    #ifndef GL_DYNAMIC_DRAW
-        #define GL_DYNAMIC_DRAW 0x88E8
-    #endif
+namespace
+{
+    const GLenum gl_types[] = { gl::UNSIGNED_BYTE, gl::BYTE, gl::UNSIGNED_SHORT, gl::SHORT, gl::INT, gl::FLOAT, gl::DOUBLE };
+}
+#endif
 
-    #ifndef GL_READ_WRITE
-        #define GL_READ_WRITE 0x88BA
-    #endif
-
-    #ifndef GL_BGR
-        #define GL_BGR 0x80E0
-    #endif
-
-    #ifndef GL_BGRA
-        #define GL_BGRA 0x80E1
-    #endif
-
-    namespace
-    {
-        const GLenum gl_types[] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE};
-
-    #ifdef HAVE_CUDA
-        bool g_isCudaGlDeviceInitialized = false;
-    #endif
-    }
-#endif // HAVE_OPENGL
+////////////////////////////////////////////////////////////////////////
+// setGlDevice
 
 void cv::gpu::setGlDevice(int device)
 {
-#if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-    (void)device;
-    throw_nocuda;
+#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER)
+    (void) device;
+    throw_nocuda();
 #else
     #ifndef HAVE_OPENGL
-        (void)device;
-        throw_nogl;
+        (void) device;
+        throw_nogl();
     #else
-        if (!glFuncTab()->isGlContextInitialized())
-            throw_nogl;
-
         cudaSafeCall( cudaGLSetGLDevice(device) );
-
-        g_isCudaGlDeviceInitialized = true;
     #endif
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////
-// CudaGlInterop
+// CudaResource
+
+#if defined(HAVE_OPENGL) && defined(HAVE_CUDA) && !defined(CUDA_DISABLER)
 
-#if defined HAVE_CUDA && defined HAVE_OPENGL
 namespace
 {
-    class CudaGlInterop
+    class CudaResource
     {
     public:
-        CudaGlInterop();
-        ~CudaGlInterop();
+        CudaResource();
+        ~CudaResource();
 
-        void registerBuffer(unsigned int buffer);
+        void registerBuffer(GLuint buffer);
+        void release();
 
-        void copyFrom(const GpuMat& mat, cudaStream_t stream = 0);
+        void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0);
+        void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0);
 
-        GpuMat map(int rows, int cols, int type, cudaStream_t stream = 0);
+        void* map(cudaStream_t stream = 0);
         void unmap(cudaStream_t stream = 0);
 
     private:
         cudaGraphicsResource_t resource_;
+        GLuint buffer_;
+
+        class GraphicsMapHolder;
     };
 
-    inline CudaGlInterop::CudaGlInterop() : resource_(0)
+    CudaResource::CudaResource() : resource_(0), buffer_(0)
     {
     }
 
-    CudaGlInterop::~CudaGlInterop()
+    CudaResource::~CudaResource()
     {
-        if (resource_)
-        {
-            cudaGraphicsUnregisterResource(resource_);
-            resource_ = 0;
-        }
+        release();
     }
 
-    void CudaGlInterop::registerBuffer(unsigned int buffer)
+    void CudaResource::registerBuffer(GLuint buffer)
     {
-        if (!g_isCudaGlDeviceInitialized)
-            cvError(CV_GpuApiCallError, "registerBuffer", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__);
+        CV_DbgAssert( buffer != 0 );
+
+        if (buffer_ == buffer)
+            return;
 
         cudaGraphicsResource_t resource;
         cudaSafeCall( cudaGraphicsGLRegisterBuffer(&resource, buffer, cudaGraphicsMapFlagsNone) );
 
+        release();
+
         resource_ = resource;
+        buffer_ = buffer;
     }
 
-    void CudaGlInterop::copyFrom(const GpuMat& mat, cudaStream_t stream)
+    void CudaResource::release()
     {
-        CV_Assert(resource_ != 0);
+        if (resource_)
+            cudaGraphicsUnregisterResource(resource_);
 
-        cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) );
+        resource_ = 0;
+        buffer_ = 0;
+    }
 
-        void* dst_ptr;
-        size_t num_bytes;
-        cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst_ptr, &num_bytes, resource_) );
+    class CudaResource::GraphicsMapHolder
+    {
+    public:
+        GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream);
+        ~GraphicsMapHolder();
 
-        const void* src_ptr = mat.ptr();
-        size_t widthBytes = mat.cols * mat.elemSize();
+        void reset();
 
-        CV_Assert(widthBytes * mat.rows <= num_bytes);
+    private:
+        cudaGraphicsResource_t* resource_;
+        cudaStream_t stream_;
+    };
+
+    CudaResource::GraphicsMapHolder::GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream) : resource_(resource), stream_(stream)
+    {
+        if (resource_)
+            cudaSafeCall( cudaGraphicsMapResources(1, resource_, stream_) );
+    }
+
+    CudaResource::GraphicsMapHolder::~GraphicsMapHolder()
+    {
+        if (resource_)
+            cudaGraphicsUnmapResources(1, resource_, stream_);
+    }
+
+    void CudaResource::GraphicsMapHolder::reset()
+    {
+        resource_ = 0;
+    }
+
+    void CudaResource::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream)
+    {
+        CV_DbgAssert( resource_ != 0 );
+
+        GraphicsMapHolder h(&resource_, stream);
+        (void) h;
+
+        void* dst;
+        size_t size;
+        cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst, &size, resource_) );
+
+        CV_DbgAssert( width * height == size );
 
         if (stream == 0)
-            cudaSafeCall( cudaMemcpy2D(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice) );
+            cudaSafeCall( cudaMemcpy2D(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice) );
         else
-            cudaSafeCall( cudaMemcpy2DAsync(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice, stream) );
-
-        cudaGraphicsUnmapResources(1, &resource_, stream);
+            cudaSafeCall( cudaMemcpy2DAsync(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice, stream) );
     }
 
-    GpuMat CudaGlInterop::map(int rows, int cols, int type, cudaStream_t stream)
+    void CudaResource::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream)
     {
-        CV_Assert(resource_ != 0);
+        CV_DbgAssert( resource_ != 0 );
 
-        cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) );
+        GraphicsMapHolder h(&resource_, stream);
+        (void) h;
+
+        void* src;
+        size_t size;
+        cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&src, &size, resource_) );
+
+        CV_DbgAssert( width * height == size );
+
+        if (stream == 0)
+            cudaSafeCall( cudaMemcpy2D(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpy2DAsync(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice, stream) );
+    }
+
+    void* CudaResource::map(cudaStream_t stream)
+    {
+        CV_DbgAssert( resource_ != 0 );
+
+        GraphicsMapHolder h(&resource_, stream);
 
         void* ptr;
-        size_t num_bytes;
-        cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &num_bytes, resource_) );
+        size_t size;
+        cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &size, resource_) );
 
-        CV_Assert( static_cast<size_t>(cols) * CV_ELEM_SIZE(type) * rows <= num_bytes );
+        h.reset();
 
-        return GpuMat(rows, cols, type, ptr);
+        return ptr;
     }
 
-    inline void CudaGlInterop::unmap(cudaStream_t stream)
+    void CudaResource::unmap(cudaStream_t stream)
     {
+        CV_Assert( resource_ != 0 );
+
         cudaGraphicsUnmapResources(1, &resource_, stream);
     }
 }
-#endif // HAVE_CUDA && HAVE_OPENGL
+
+#endif
 
 ////////////////////////////////////////////////////////////////////////
 // GlBuffer
@@ -296,393 +326,457 @@ class cv::GlBuffer::Impl
 public:
     static const Ptr<Impl>& empty();
 
-    Impl(int rows, int cols, int type, unsigned int target);
-    Impl(const Mat& m, unsigned int target);
+    Impl(GLuint bufId, bool autoRelease);
+    Impl(GLsizeiptr size, const GLvoid* data, GLenum target);
     ~Impl();
 
-    void copyFrom(const Mat& m, unsigned int target);
+    void bind(GLenum target) const;
+
+    void copyFrom(GLuint srcBuf, GLsizeiptr size);
+
+    void copyFrom(GLsizeiptr size, const GLvoid* data);
+    void copyTo(GLsizeiptr size, GLvoid* data) const;
+
+    void* mapHost();
+    void unmapHost();
 
 #ifdef HAVE_CUDA
-    void copyFrom(const GpuMat& mat, cudaStream_t stream = 0);
-#endif
+    void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0);
+    void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0) const;
 
-    void bind(unsigned int target) const;
-    void unbind(unsigned int target) const;
-
-    Mat mapHost(int rows, int cols, int type, unsigned int target);
-    void unmapHost(unsigned int target);
-
-#ifdef HAVE_CUDA
-    GpuMat mapDevice(int rows, int cols, int type, cudaStream_t stream = 0);
+    void* mapDevice(cudaStream_t stream = 0);
     void unmapDevice(cudaStream_t stream = 0);
 #endif
 
+    void setAutoRelease(bool flag) { autoRelease_ = flag; }
+
+    GLuint bufId() const { return bufId_; }
+
 private:
     Impl();
 
-    unsigned int buffer_;
+    GLuint bufId_;
+    bool autoRelease_;
 
 #ifdef HAVE_CUDA
-    CudaGlInterop cudaGlInterop_;
+    mutable CudaResource cudaResource_;
 #endif
 };
 
-inline const Ptr<cv::GlBuffer::Impl>& cv::GlBuffer::Impl::empty()
+const Ptr<cv::GlBuffer::Impl>& cv::GlBuffer::Impl::empty()
 {
     static Ptr<Impl> p(new Impl);
     return p;
 }
 
-inline cv::GlBuffer::Impl::Impl() : buffer_(0)
+cv::GlBuffer::Impl::Impl() : bufId_(0), autoRelease_(true)
 {
 }
 
-cv::GlBuffer::Impl::Impl(int rows, int cols, int type, unsigned int target) : buffer_(0)
+cv::GlBuffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), autoRelease_(autoRelease)
 {
-    if (!glFuncTab()->isGlContextInitialized())
-        throw_nogl;
-
-    CV_DbgAssert(rows > 0 && cols > 0);
-    CV_DbgAssert(CV_MAT_DEPTH(type) >= 0 && CV_MAT_DEPTH(type) <= CV_64F);
-
-    glFuncTab()->genBuffers(1, &buffer_);
-    CV_CheckGlError();
-    CV_Assert(buffer_ != 0);
-
-    size_t size = rows * cols * CV_ELEM_SIZE(type);
-
-    glFuncTab()->bindBuffer(target, buffer_);
-    CV_CheckGlError();
-
-    glFuncTab()->bufferData(target, size, 0, GL_DYNAMIC_DRAW);
-    CV_CheckGlError();
-
-    glFuncTab()->bindBuffer(target, 0);
-
-#ifdef HAVE_CUDA
-    if (g_isCudaGlDeviceInitialized)
-        cudaGlInterop_.registerBuffer(buffer_);
-#endif
 }
 
-cv::GlBuffer::Impl::Impl(const Mat& m, unsigned int target) : buffer_(0)
+cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target) : bufId_(0), autoRelease_(true)
 {
-    if (!glFuncTab()->isGlContextInitialized())
-        throw_nogl;
-
-    CV_DbgAssert(m.rows > 0 && m.cols > 0);
-    CV_DbgAssert(m.depth() >= 0 && m.depth() <= CV_64F);
-    CV_Assert(m.isContinuous());
-
-    glFuncTab()->genBuffers(1, &buffer_);
-    CV_CheckGlError();
-    CV_Assert(buffer_ != 0);
-
-    size_t size = m.rows * m.cols * m.elemSize();
-
-    glFuncTab()->bindBuffer(target, buffer_);
+    gl::GenBuffers(1, &bufId_);
     CV_CheckGlError();
 
-    glFuncTab()->bufferData(target, size, m.data, GL_DYNAMIC_DRAW);
+    CV_Assert( bufId_ != 0 );
+
+    gl::BindBuffer(target, bufId_);
     CV_CheckGlError();
 
-    glFuncTab()->bindBuffer(target, 0);
+    gl::BufferData(target, size, data, gl::DYNAMIC_DRAW);
+    CV_CheckGlError();
 
-#ifdef HAVE_CUDA
-    if (g_isCudaGlDeviceInitialized)
-        cudaGlInterop_.registerBuffer(buffer_);
-#endif
+    gl::BindBuffer(target, 0);
+    CV_CheckGlError();
 }
 
 cv::GlBuffer::Impl::~Impl()
 {
-    try
+    if (autoRelease_ && bufId_)
+        gl::DeleteBuffers(1, &bufId_);
+}
+
+void cv::GlBuffer::Impl::bind(GLenum target) const
+{
+    gl::BindBuffer(target, bufId_);
+    CV_CheckGlError();
+}
+
+void cv::GlBuffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size)
+{
+    gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_);
+    CV_CheckGlError();
+
+    gl::BindBuffer(gl::COPY_READ_BUFFER, srcBuf);
+    CV_CheckGlError();
+
+    gl::CopyBufferSubData(gl::COPY_READ_BUFFER, gl::COPY_WRITE_BUFFER, 0, 0, size);
+    CV_CheckGlError();
+}
+
+void cv::GlBuffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data)
+{
+    gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_);
+    CV_CheckGlError();
+
+    gl::BufferSubData(gl::COPY_WRITE_BUFFER, 0, size, data);
+    CV_CheckGlError();
+}
+
+void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const
+{
+    gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_);
+    CV_CheckGlError();
+
+    gl::GetBufferSubData(gl::COPY_READ_BUFFER, 0, size, data);
+    CV_CheckGlError();
+}
+
+void* cv::GlBuffer::Impl::mapHost()
+{
+    gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_);
+    CV_CheckGlError();
+
+    GLvoid* data = gl::MapBuffer(gl::COPY_READ_BUFFER, gl::READ_WRITE);
+    CV_CheckGlError();
+
+    return data;
+}
+
+void cv::GlBuffer::Impl::unmapHost()
+{
+    gl::UnmapBuffer(gl::COPY_READ_BUFFER);
+}
+
+#ifdef HAVE_CUDA
+    void cv::GlBuffer::Impl::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream)
     {
-        if (buffer_)
-            glFuncTab()->deleteBuffers(1, &buffer_);
+        cudaResource_.registerBuffer(bufId_);
+        cudaResource_.copyFrom(src, spitch, width, height, stream);
     }
-#ifdef _DEBUG
-    catch(const exception& e)
+
+    void cv::GlBuffer::Impl::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) const
     {
-        cerr << e.what() << endl;
+        cudaResource_.registerBuffer(bufId_);
+        cudaResource_.copyTo(dst, dpitch, width, height, stream);
+    }
+
+    void* cv::GlBuffer::Impl::mapDevice(cudaStream_t stream)
+    {
+        cudaResource_.registerBuffer(bufId_);
+        return cudaResource_.map(stream);
+    }
+
+    void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream)
+    {
+        cudaResource_.unmap(stream);
     }
 #endif
-    catch(...)
-    {
-    }
-}
-
-void cv::GlBuffer::Impl::copyFrom(const Mat& m, unsigned int target)
-{
-    CV_Assert(buffer_ != 0);
-
-    CV_Assert(m.isContinuous());
-
-    bind(target);
-
-    size_t size = m.rows * m.cols * m.elemSize();
-
-    glFuncTab()->bufferSubData(target, 0, size, m.data);
-    CV_CheckGlError();
-
-    unbind(target);
-}
-
-#ifdef HAVE_CUDA
-
-void cv::GlBuffer::Impl::copyFrom(const GpuMat& mat, cudaStream_t stream)
-{
-    if (!g_isCudaGlDeviceInitialized)
-        cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__);
-
-    CV_Assert(buffer_ != 0);
-
-    cudaGlInterop_.copyFrom(mat, stream);
-}
-
-#endif // HAVE_CUDA
-
-inline void cv::GlBuffer::Impl::bind(unsigned int target) const
-{
-    CV_Assert(buffer_ != 0);
-
-    glFuncTab()->bindBuffer(target, buffer_);
-    CV_CheckGlError();
-}
-
-inline void cv::GlBuffer::Impl::unbind(unsigned int target) const
-{
-    glFuncTab()->bindBuffer(target, 0);
-}
-
-inline Mat cv::GlBuffer::Impl::mapHost(int rows, int cols, int type, unsigned int target)
-{
-    void* ptr = glFuncTab()->mapBuffer(target, GL_READ_WRITE);
-    CV_CheckGlError();
-
-    return Mat(rows, cols, type, ptr);
-}
-
-inline void cv::GlBuffer::Impl::unmapHost(unsigned int target)
-{
-    glFuncTab()->unmapBuffer(target);
-}
-
-#ifdef HAVE_CUDA
-
-inline GpuMat cv::GlBuffer::Impl::mapDevice(int rows, int cols, int type, cudaStream_t stream)
-{
-    if (!g_isCudaGlDeviceInitialized)
-        cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__);
-
-    CV_Assert(buffer_ != 0);
-
-    return cudaGlInterop_.map(rows, cols, type, stream);
-}
-
-inline void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream)
-{
-    if (!g_isCudaGlDeviceInitialized)
-        cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__);
-
-    cudaGlInterop_.unmap(stream);
-}
-
-#endif // HAVE_CUDA
 
 #endif // HAVE_OPENGL
 
-cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+cv::GlBuffer::GlBuffer() : rows_(0), cols_(0), type_(0)
 {
 #ifndef HAVE_OPENGL
-    (void)_usage;
-    throw_nogl;
+    throw_nogl();
 #else
     impl_ = Impl::empty();
 #endif
 }
 
-cv::GlBuffer::GlBuffer(int _rows, int _cols, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+cv::GlBuffer::GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0)
 {
 #ifndef HAVE_OPENGL
-    (void)_rows;
-    (void)_cols;
-    (void)_type;
-    (void)_usage;
-    throw_nogl;
+    (void) arows;
+    (void) acols;
+    (void) atype;
+    (void) abufId;
+    (void) autoRelease;
+    throw_nogl();
 #else
-    impl_ = new Impl(_rows, _cols, _type, _usage);
-    rows_ = _rows;
-    cols_ = _cols;
-    type_ = _type;
+    impl_ = new Impl(abufId, autoRelease);
+    rows_ = arows;
+    cols_ = acols;
+    type_ = atype;
 #endif
 }
 
-cv::GlBuffer::GlBuffer(Size _size, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0)
 {
 #ifndef HAVE_OPENGL
-    (void)_size;
-    (void)_type;
-    (void)_usage;
-    throw_nogl;
+    (void) asize;
+    (void) atype;
+    (void) abufId;
+    (void) autoRelease;
+    throw_nogl();
 #else
-    impl_ = new Impl(_size.height, _size.width, _type, _usage);
-    rows_ = _size.height;
-    cols_ = _size.width;
-    type_ = _type;
+    impl_ = new Impl(abufId, autoRelease);
+    rows_ = asize.height;
+    cols_ = asize.width;
+    type_ = atype;
 #endif
 }
 
-cv::GlBuffer::GlBuffer(InputArray mat_, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
+cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target) : rows_(0), cols_(0), type_(0)
+{
+    create(arows, acols, atype, target);
+}
+
+cv::GlBuffer::GlBuffer(Size asize, int atype, Target target) : rows_(0), cols_(0), type_(0)
+{
+    create(asize, atype, target);
+}
+
+cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type_(0)
 {
 #ifndef HAVE_OPENGL
-    (void)mat_;
-    (void)_usage;
-    throw_nogl;
+    (void) arr;
+    (void) target;
+    throw_nogl();
 #else
-    int kind = mat_.kind();
-    Size _size = mat_.size();
-    int _type = mat_.type();
+    const int kind = arr.kind();
 
-    if (kind == _InputArray::GPU_MAT)
+    switch (kind)
     {
-        #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-            throw_nocuda;
-        #else
-            GpuMat d_mat = mat_.getGpuMat();
-            impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), _usage);
-            impl_->copyFrom(d_mat);
-        #endif
+    case _InputArray::OPENGL_BUFFER:
+        {
+            copyFrom(arr, target);
+            break;
+        }
+
+    case _InputArray::OPENGL_TEXTURE2D:
+        {
+            copyFrom(arr, target);
+            break;
+        }
+
+    case _InputArray::GPU_MAT:
+        {
+            copyFrom(arr, target);
+            break;
+        }
+
+    default:
+        {
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            const GLsizeiptr asize = mat.rows * mat.cols * mat.elemSize();
+            impl_ = new Impl(asize, mat.data, target);
+            rows_ = mat.rows;
+            cols_ = mat.cols;
+            type_ = mat.type();
+            break;
+        }
     }
-    else
-    {
-        Mat mat = mat_.getMat();
-        impl_ = new Impl(mat, _usage);
-    }
-
-    rows_ = _size.height;
-    cols_ = _size.width;
-    type_ = _type;
 #endif
 }
 
-void cv::GlBuffer::create(int _rows, int _cols, int _type, Usage _usage)
+void cv::GlBuffer::create(int arows, int acols, int atype, Target target)
 {
 #ifndef HAVE_OPENGL
-    (void)_rows;
-    (void)_cols;
-    (void)_type;
-    (void)_usage;
-    throw_nogl;
+    (void) arows;
+    (void) acols;
+    (void) atype;
+    (void) target;
+    throw_nogl();
 #else
-    if (rows_ != _rows || cols_ != _cols || type_ != _type || usage_ != _usage)
+    if (rows_ != arows || cols_ != acols || type_ != atype)
     {
-        impl_ = new Impl(_rows, _cols, _type, _usage);
-        rows_ = _rows;
-        cols_ = _cols;
-        type_ = _type;
-        usage_ = _usage;
+        const GLsizeiptr asize = arows * acols * CV_ELEM_SIZE(atype);
+        impl_ = new Impl(asize, 0, target);
+        rows_ = arows;
+        cols_ = acols;
+        type_ = atype;
     }
 #endif
 }
 
 void cv::GlBuffer::release()
 {
-#ifndef HAVE_OPENGL
-    throw_nogl;
-#else
+#ifdef HAVE_OPENGL
     impl_ = Impl::empty();
+    rows_ = 0;
+    cols_ = 0;
+    type_ = 0;
 #endif
 }
 
-void cv::GlBuffer::copyFrom(InputArray mat_)
+void cv::GlBuffer::setAutoRelease(bool flag)
 {
 #ifndef HAVE_OPENGL
-    (void)mat_;
-    throw_nogl;
+    (void) flag;
+    throw_nogl();
 #else
-    int kind = mat_.kind();
-    Size _size = mat_.size();
-    int _type = mat_.type();
+    impl_->setAutoRelease(flag);
+#endif
+}
 
-    create(_size, _type);
+void cv::GlBuffer::copyFrom(InputArray arr, Target target)
+{
+#ifndef HAVE_OPENGL
+    (void) arr;
+    (void) target;
+    throw_nogl();
+#else
+    const int kind = arr.kind();
+
+    if (kind == _InputArray::OPENGL_TEXTURE2D)
+    {
+        GlTexture2D tex = arr.getGlTexture2D();
+        tex.copyTo(*this);
+        return;
+    }
+
+    const Size asize = arr.size();
+    const int atype = arr.type();
+    create(asize, atype, target);
 
     switch (kind)
     {
     case _InputArray::OPENGL_BUFFER:
         {
-            GlBuffer buf = mat_.getGlBuffer();
-            *this = buf;
+            GlBuffer buf = arr.getGlBuffer();
+            impl_->copyFrom(buf.bufId(), asize.area() * CV_ELEM_SIZE(atype));
             break;
         }
+
     case _InputArray::GPU_MAT:
         {
             #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-                throw_nocuda;
+                throw_nocuda();
             #else
-                GpuMat d_mat = mat_.getGpuMat();
-                impl_->copyFrom(d_mat);
+                GpuMat dmat = arr.getGpuMat();
+                impl_->copyFrom(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows);
             #endif
 
             break;
         }
+
     default:
         {
-            Mat mat = mat_.getMat();
-            impl_->copyFrom(mat, usage_);
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            impl_->copyFrom(asize.area() * CV_ELEM_SIZE(atype), mat.data);
         }
     }
 #endif
 }
 
-void cv::GlBuffer::bind() const
+void cv::GlBuffer::copyTo(OutputArray arr, Target target) const
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    (void) arr;
+    (void) target;
+    throw_nogl();
 #else
-    impl_->bind(usage_);
+    const int kind = arr.kind();
+
+    switch (kind)
+    {
+    case _InputArray::OPENGL_BUFFER:
+        {
+            arr.getGlBufferRef().copyFrom(*this, target);
+            break;
+        }
+
+    case _InputArray::OPENGL_TEXTURE2D:
+        {
+            arr.getGlTexture2DRef().copyFrom(*this);
+            break;
+        }
+
+    case _InputArray::GPU_MAT:
+        {
+            #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
+                throw_nocuda();
+            #else
+                GpuMat& dmat = arr.getGpuMatRef();
+                dmat.create(rows_, cols_, type_);
+                impl_->copyTo(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows);
+            #endif
+
+            break;
+        }
+
+    default:
+        {
+            arr.create(rows_, cols_, type_);
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            impl_->copyTo(mat.rows * mat.cols * mat.elemSize(), mat.data);
+        }
+    }
 #endif
 }
 
-void cv::GlBuffer::unbind() const
+GlBuffer cv::GlBuffer::clone(Target target) const
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    (void) target;
+    throw_nogl();
+    return GlBuffer();
 #else
-    impl_->unbind(usage_);
+    GlBuffer buf;
+    buf.copyFrom(*this, target);
+    return buf;
+#endif
+}
+
+void cv::GlBuffer::bind(Target target) const
+{
+#ifndef HAVE_OPENGL
+    (void) target;
+    throw_nogl();
+#else
+    impl_->bind(target);
+#endif
+}
+
+void cv::GlBuffer::unbind(Target target)
+{
+#ifndef HAVE_OPENGL
+    (void) target;
+    throw_nogl();
+#else
+    gl::BindBuffer(target, 0);
+    CV_CheckGlError();
 #endif
 }
 
 Mat cv::GlBuffer::mapHost()
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
     return Mat();
 #else
-    return impl_->mapHost(rows_, cols_, type_, usage_);
+    return Mat(rows_, cols_, type_, impl_->mapHost());
 #endif
 }
 
 void cv::GlBuffer::unmapHost()
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
 #else
-    impl_->unmapHost(usage_);
+    return impl_->unmapHost();
 #endif
 }
 
 GpuMat cv::GlBuffer::mapDevice()
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
     return GpuMat();
 #else
     #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-        throw_nocuda;
+        throw_nocuda();
         return GpuMat();
     #else
-        return impl_->mapDevice(rows_, cols_, type_);
+        return GpuMat(rows_, cols_, type_, impl_->mapDevice());
     #endif
 #endif
 }
@@ -690,418 +784,437 @@ GpuMat cv::GlBuffer::mapDevice()
 void cv::GlBuffer::unmapDevice()
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
 #else
     #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-        throw_nocuda;
+        throw_nocuda();
     #else
         impl_->unmapDevice();
     #endif
 #endif
 }
 
+unsigned int cv::GlBuffer::bufId() const
+{
+#ifndef HAVE_OPENGL
+    throw_nogl();
+    return 0;
+#else
+    return impl_->bufId();
+#endif
+}
+
 template <> void cv::Ptr<cv::GlBuffer::Impl>::delete_obj()
 {
     if (obj) delete obj;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// GlTexture
+// GlTexture2D
 
 #ifndef HAVE_OPENGL
 
-class cv::GlTexture::Impl
+class cv::GlTexture2D::Impl
 {
 };
 
 #else
 
-class cv::GlTexture::Impl
+class cv::GlTexture2D::Impl
 {
 public:
     static const Ptr<Impl> empty();
 
-    Impl(int rows, int cols, int type);
-
-    Impl(const Mat& mat, bool bgra);
-    Impl(const GlBuffer& buf, bool bgra);
-
+    Impl(GLuint texId, bool autoRelease);
+    Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
     ~Impl();
 
-    void copyFrom(const Mat& mat, bool bgra);
-    void copyFrom(const GlBuffer& buf, bool bgra);
+    void copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+    void copyTo(GLenum format, GLenum type, GLvoid* pixels) const;
 
     void bind() const;
-    void unbind() const;
+
+    void setAutoRelease(bool flag) { autoRelease_ = flag; }
+
+    GLuint texId() const { return texId_; }
 
 private:
     Impl();
 
-    GLuint tex_;
+    GLuint texId_;
+    bool autoRelease_;
 };
 
-inline const Ptr<cv::GlTexture::Impl> cv::GlTexture::Impl::empty()
+const Ptr<cv::GlTexture2D::Impl> cv::GlTexture2D::Impl::empty()
 {
     static Ptr<Impl> p(new Impl);
     return p;
 }
 
-inline cv::GlTexture::Impl::Impl() : tex_(0)
+cv::GlTexture2D::Impl::Impl() : texId_(0), autoRelease_(true)
 {
 }
 
-cv::GlTexture::Impl::Impl(int rows, int cols, int type) : tex_(0)
+cv::GlTexture2D::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), autoRelease_(autoRelease)
 {
-    if (!glFuncTab()->isGlContextInitialized())
-        throw_nogl;
+}
 
-    int depth = CV_MAT_DEPTH(type);
-    int cn = CV_MAT_CN(type);
-
-    CV_DbgAssert(rows > 0 && cols > 0);
-    CV_Assert(cn == 1 || cn == 3 || cn == 4);
-    CV_Assert(depth >= 0 && depth <= CV_32F);
-
-    glGenTextures(1, &tex_);
-    CV_CheckGlError();
-    CV_Assert(tex_ != 0);
-
-    glBindTexture(GL_TEXTURE_2D, tex_);
+cv::GlTexture2D::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) : texId_(0), autoRelease_(true)
+{
+    gl::GenTextures(1, &texId_);
     CV_CheckGlError();
 
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    CV_Assert(texId_ != 0);
+
+    gl::BindTexture(gl::TEXTURE_2D, texId_);
     CV_CheckGlError();
 
-    GLenum format = cn == 1 ? GL_LUMINANCE : cn == 3 ? GL_BGR : GL_BGRA;
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1);
     CV_CheckGlError();
 
-    glTexImage2D(GL_TEXTURE_2D, 0, cn, cols, rows, 0, format, gl_types[depth], 0);
+    gl::TexImage2D(gl::TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, pixels);
+    CV_CheckGlError();
+
+    gl::GenerateMipmap(gl::TEXTURE_2D);
     CV_CheckGlError();
 }
 
-cv::GlTexture::Impl::Impl(const Mat& mat, bool bgra) : tex_(0)
+cv::GlTexture2D::Impl::~Impl()
 {
-    if (!glFuncTab()->isGlContextInitialized())
-        throw_nogl;
+    if (autoRelease_ && texId_)
+        gl::DeleteTextures(1, &texId_);
+}
 
-    int depth = mat.depth();
-    int cn = mat.channels();
-
-    CV_DbgAssert(mat.rows > 0 && mat.cols > 0);
-    CV_Assert(cn == 1 || cn == 3 || cn == 4);
-    CV_Assert(depth >= 0 && depth <= CV_32F);
-    CV_Assert(mat.isContinuous());
-
-    glGenTextures(1, &tex_);
-    CV_CheckGlError();
-    CV_Assert(tex_ != 0);
-
-    glBindTexture(GL_TEXTURE_2D, tex_);
+void cv::GlTexture2D::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+{
+    gl::BindTexture(gl::TEXTURE_2D, texId_);
     CV_CheckGlError();
 
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1);
     CV_CheckGlError();
 
-    GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA));
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    gl::TexSubImage2D(gl::TEXTURE_2D, 0, 0, 0, width, height, format, type, pixels);
     CV_CheckGlError();
 
-    glTexImage2D(GL_TEXTURE_2D, 0, cn, mat.cols, mat.rows, 0, format, gl_types[depth], mat.data);
+    gl::GenerateMipmap(gl::TEXTURE_2D);
     CV_CheckGlError();
 }
 
-cv::GlTexture::Impl::Impl(const GlBuffer& buf, bool bgra) : tex_(0)
+void cv::GlTexture2D::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) const
 {
-    if (!glFuncTab()->isGlContextInitialized())
-        throw_nogl;
-
-    int depth = buf.depth();
-    int cn = buf.channels();
-
-    CV_DbgAssert(buf.rows() > 0 && buf.cols() > 0);
-    CV_Assert(cn == 1 || cn == 3 || cn == 4);
-    CV_Assert(depth >= 0 && depth <= CV_32F);
-    CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER);
-
-    glGenTextures(1, &tex_);
-    CV_CheckGlError();
-    CV_Assert(tex_ != 0);
-
-    glBindTexture(GL_TEXTURE_2D, tex_);
+    gl::BindTexture(gl::TEXTURE_2D, texId_);
     CV_CheckGlError();
 
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    gl::PixelStorei(gl::PACK_ALIGNMENT, 1);
     CV_CheckGlError();
 
-    GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA));
-
-    buf.bind();
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    CV_CheckGlError();
-
-    glTexImage2D(GL_TEXTURE_2D, 0, cn, buf.cols(), buf.rows(), 0, format, gl_types[depth], 0);
-    CV_CheckGlError();
-
-    buf.unbind();
-}
-
-inline cv::GlTexture::Impl::~Impl()
-{
-    if (tex_)
-        glDeleteTextures(1, &tex_);
-}
-
-void cv::GlTexture::Impl::copyFrom(const Mat& mat, bool bgra)
-{
-    CV_Assert(tex_ != 0);
-
-    bind();
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    CV_CheckGlError();
-
-    int cn = mat.channels();
-    GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA));
-
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mat.cols, mat.rows, format, gl_types[mat.depth()], mat.data);
-    CV_CheckGlError();
-
-    unbind();
-}
-
-void cv::GlTexture::Impl::copyFrom(const GlBuffer& buf, bool bgra)
-{
-    CV_Assert(tex_ != 0);
-    CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER);
-
-    bind();
-
-    buf.bind();
-
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    CV_CheckGlError();
-
-    int cn = buf.channels();
-    GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA));
-
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, buf.cols(), buf.rows(), format, gl_types[buf.depth()], 0);
-    CV_CheckGlError();
-
-    buf.unbind();
-
-    unbind();
-}
-
-inline void cv::GlTexture::Impl::bind() const
-{
-    CV_Assert(tex_ != 0);
-
-    glEnable(GL_TEXTURE_2D);
-    CV_CheckGlError();
-
-    glBindTexture(GL_TEXTURE_2D, tex_);
+    gl::GetTexImage(gl::TEXTURE_2D, 0, format, type, pixels);
     CV_CheckGlError();
 }
 
-inline void cv::GlTexture::Impl::unbind() const
+void cv::GlTexture2D::Impl::bind() const
 {
-    glBindTexture(GL_TEXTURE_2D, 0);
-
-    glDisable(GL_TEXTURE_2D);
+    gl::BindTexture(gl::TEXTURE_2D, texId_);
+    CV_CheckGlError();
 }
 
 #endif // HAVE_OPENGL
 
-cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture2D::GlTexture2D() : rows_(0), cols_(0), format_(NONE)
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
 #else
     impl_ = Impl::empty();
 #endif
 }
 
-cv::GlTexture::GlTexture(int _rows, int _cols, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
 {
 #ifndef HAVE_OPENGL
-    (void)_rows;
-    (void)_cols;
-    (void)_type;
-    throw_nogl;
+    (void) arows;
+    (void) acols;
+    (void) aformat;
+    (void) atexId;
+    (void) autoRelease;
+    throw_nogl();
 #else
-    impl_ = new Impl(_rows, _cols, _type);
-    rows_ = _rows;
-    cols_ = _cols;
-    type_ = _type;
+    impl_ = new Impl(atexId, autoRelease);
+    rows_ = arows;
+    cols_ = acols;
+    format_ = aformat;
 #endif
 }
 
-cv::GlTexture::GlTexture(Size _size, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture2D::GlTexture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
 {
 #ifndef HAVE_OPENGL
-    (void)_size;
-    (void)_type;
-    throw_nogl;
+    (void) asize;
+    (void) aformat;
+    (void) atexId;
+    (void) autoRelease;
+    throw_nogl();
 #else
-    impl_ = new Impl(_size.height, _size.width, _type);
-    rows_ = _size.height;
-    cols_ = _size.width;
-    type_ = _type;
+    impl_ = new Impl(atexId, autoRelease);
+    rows_ = asize.height;
+    cols_ = asize.width;
+    format_ = aformat;
 #endif
 }
 
-cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
+cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat) : rows_(0), cols_(0), format_(NONE)
+{
+    create(arows, acols, aformat);
+}
+
+cv::GlTexture2D::GlTexture2D(Size asize, Format aformat) : rows_(0), cols_(0), format_(NONE)
+{
+    create(asize, aformat);
+}
+
+cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
 {
 #ifndef HAVE_OPENGL
-    (void)mat_;
-    (void)bgra;
-    throw_nogl;
+    (void) arr;
+    throw_nogl();
 #else
-    int kind = mat_.kind();
-    Size _size = mat_.size();
-    int _type = mat_.type();
+    const int kind = arr.kind();
+
+    const Size asize = arr.size();
+    const int atype = arr.type();
+
+    const int depth = CV_MAT_DEPTH(atype);
+    const int cn = CV_MAT_CN(atype);
+
+    CV_Assert( depth <= CV_32F );
+    CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+
+    const Format internalFormats[] =
+    {
+        NONE, DEPTH_COMPONENT, NONE, RGB, RGBA
+    };
+    const GLenum srcFormats[] =
+    {
+        0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA
+    };
 
     switch (kind)
     {
     case _InputArray::OPENGL_BUFFER:
         {
-            GlBuffer buf = mat_.getGlBuffer();
-            impl_ = new Impl(buf, bgra);
+            GlBuffer buf = arr.getGlBuffer();
+            buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
+            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+            GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             break;
         }
+
     case _InputArray::GPU_MAT:
         {
             #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-                throw_nocuda;
+                throw_nocuda();
             #else
-                GpuMat d_mat = mat_.getGpuMat();
-                GlBuffer buf(d_mat, GlBuffer::TEXTURE_BUFFER);
-                impl_ = new Impl(buf, bgra);
+                GpuMat dmat = arr.getGpuMat();
+                GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER);
+                buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
+                impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+                GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             #endif
 
             break;
         }
+
     default:
         {
-            Mat mat = mat_.getMat();
-            impl_ = new Impl(mat, bgra);
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
+            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data);
             break;
         }
     }
 
-    rows_ = _size.height;
-    cols_ = _size.width;
-    type_ = _type;
+    rows_ = asize.height;
+    cols_ = asize.width;
+    format_ = internalFormats[cn];
 #endif
 }
 
-void cv::GlTexture::create(int _rows, int _cols, int _type)
+void cv::GlTexture2D::create(int arows, int acols, Format aformat)
 {
 #ifndef HAVE_OPENGL
-    (void)_rows;
-    (void)_cols;
-    (void)_type;
-    throw_nogl;
+    (void) arows;
+    (void) acols;
+    (void) aformat;
+    throw_nogl();
 #else
-    if (rows_ != _rows || cols_ != _cols || type_ != _type)
+    if (rows_ != arows || cols_ != acols || format_ != aformat)
     {
-        impl_ = new Impl(_rows, _cols, _type);
-        rows_ = _rows;
-        cols_ = _cols;
-        type_ = _type;
+        GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
+        impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0);
+        rows_ = arows;
+        cols_ = acols;
+        format_ = aformat;
     }
 #endif
 }
 
-void cv::GlTexture::release()
+void cv::GlTexture2D::release()
 {
-#ifndef HAVE_OPENGL
-    throw_nogl;
-#else
+#ifdef HAVE_OPENGL
     impl_ = Impl::empty();
+    rows_ = 0;
+    cols_ = 0;
+    format_ = NONE;
 #endif
 }
 
-void cv::GlTexture::copyFrom(InputArray mat_, bool bgra)
+void cv::GlTexture2D::setAutoRelease(bool flag)
 {
 #ifndef HAVE_OPENGL
-    (void)mat_;
-    (void)bgra;
-    throw_nogl;
+    (void) flag;
+    throw_nogl();
 #else
-    int kind = mat_.kind();
-    Size _size = mat_.size();
-    int _type = mat_.type();
+    impl_->setAutoRelease(flag);
+#endif
+}
 
-    create(_size, _type);
+void cv::GlTexture2D::copyFrom(InputArray arr)
+{
+#ifndef HAVE_OPENGL
+    (void) arr;
+    throw_nogl();
+#else
+    const int kind = arr.kind();
+
+    const Size asize = arr.size();
+    const int atype = arr.type();
+
+    const int depth = CV_MAT_DEPTH(atype);
+    const int cn = CV_MAT_CN(atype);
+
+    CV_Assert( depth <= CV_32F );
+    CV_Assert( cn == 1 || cn == 3 || cn == 4 );
+
+    const Format internalFormats[] =
+    {
+        NONE, DEPTH_COMPONENT, NONE, RGB, RGBA
+    };
+    const GLenum srcFormats[] =
+    {
+        0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA
+    };
+
+    create(asize, internalFormats[cn]);
 
     switch(kind)
     {
-    case _InputArray::OPENGL_TEXTURE:
-        {
-            GlTexture tex = mat_.getGlTexture();
-            *this = tex;
-            break;
-        }
     case _InputArray::OPENGL_BUFFER:
         {
-            GlBuffer buf = mat_.getGlBuffer();
-            impl_->copyFrom(buf, bgra);
+            GlBuffer buf = arr.getGlBuffer();
+            buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
+            impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+            GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             break;
         }
+
     case _InputArray::GPU_MAT:
         {
             #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
-                throw_nocuda;
+                throw_nocuda();
             #else
-                GpuMat d_mat = mat_.getGpuMat();
-                buf_.copyFrom(d_mat);
-                impl_->copyFrom(buf_, bgra);
+                GpuMat dmat = arr.getGpuMat();
+                GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER);
+                buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
+                impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+                GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             #endif
 
             break;
         }
+
     default:
         {
-            Mat mat = mat_.getMat();
-            impl_->copyFrom(mat, bgra);
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
+            impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data);
         }
     }
 #endif
 }
 
-void cv::GlTexture::bind() const
+void cv::GlTexture2D::copyTo(OutputArray arr, int ddepth) const
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    (void) arr;
+    (void) ddepth;
+    throw_nogl();
+#else
+    const int kind = arr.kind();
+
+    const int cn = format_ == DEPTH_COMPONENT ? 1: format_ == RGB ? 3 : 4;
+    const GLenum dstFormat = format_ == DEPTH_COMPONENT ? gl::DEPTH_COMPONENT : format_ == RGB ? gl::BGR : gl::BGRA;
+
+    switch(kind)
+    {
+    case _InputArray::OPENGL_BUFFER:
+        {
+            GlBuffer& buf = arr.getGlBufferRef();
+            buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER);
+            buf.bind(GlBuffer::PIXEL_PACK_BUFFER);
+            impl_->copyTo(dstFormat, gl_types[ddepth], 0);
+            GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER);
+            break;
+        }
+
+    case _InputArray::GPU_MAT:
+        {
+            #if !defined HAVE_CUDA || defined(CUDA_DISABLER)
+                throw_nocuda();
+            #else
+                GlBuffer buf(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER);
+                buf.bind(GlBuffer::PIXEL_PACK_BUFFER);
+                impl_->copyTo(dstFormat, gl_types[ddepth], 0);
+                GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER);
+                buf.copyTo(arr);
+            #endif
+
+            break;
+        }
+
+    default:
+        {
+            arr.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn));
+            Mat mat = arr.getMat();
+            CV_Assert( mat.isContinuous() );
+            GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER);
+            impl_->copyTo(dstFormat, gl_types[ddepth], mat.data);
+        }
+    }
+#endif
+}
+
+void cv::GlTexture2D::bind() const
+{
+#ifndef HAVE_OPENGL
+    throw_nogl();
 #else
     impl_->bind();
 #endif
 }
 
-void cv::GlTexture::unbind() const
+unsigned int cv::GlTexture2D::texId() const
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
+    return 0;
 #else
-    impl_->unbind();
+    return impl_->texId();
 #endif
 }
 
-template <> void cv::Ptr<cv::GlTexture::Impl>::delete_obj()
+template <> void cv::Ptr<cv::GlTexture2D::Impl>::delete_obj()
 {
     if (obj) delete obj;
 }
@@ -1109,266 +1222,253 @@ template <> void cv::Ptr<cv::GlTexture::Impl>::delete_obj()
 ////////////////////////////////////////////////////////////////////////
 // GlArrays
 
-void cv::GlArrays::setVertexArray(InputArray vertex)
+cv::GlArrays::GlArrays() : size_(0)
 {
-    int cn = vertex.channels();
-    int depth = vertex.depth();
-
-    CV_Assert(cn == 2 || cn == 3 || cn == 4);
-    CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F);
-
-    vertex_.copyFrom(vertex);
 }
 
-void cv::GlArrays::setColorArray(InputArray color, bool bgra)
+void cv::GlArrays::setVertexArray(InputArray vertex)
 {
-    int cn = color.channels();
+    const int cn = vertex.channels();
+    const int depth = vertex.depth();
 
-    CV_Assert((cn == 3 && !bgra) || cn == 4);
+    CV_Assert( cn == 2 || cn == 3 || cn == 4 );
+    CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F );
 
-    color_.copyFrom(color);
-    bgra_ = bgra;
+    if (vertex.kind() == _InputArray::OPENGL_BUFFER)
+        vertex_ = vertex.getGlBuffer();
+    else
+        vertex_.copyFrom(vertex);
+
+    size_ = vertex_.size().area();
+}
+
+void cv::GlArrays::resetVertexArray()
+{
+    vertex_.release();
+    size_ = 0;
+}
+
+void cv::GlArrays::setColorArray(InputArray color)
+{
+    const int cn = color.channels();
+
+    CV_Assert( cn == 3 || cn == 4 );
+
+    if (color.kind() == _InputArray::OPENGL_BUFFER)
+        color_ = color.getGlBuffer();
+    else
+        color_.copyFrom(color);
+}
+
+void cv::GlArrays::resetColorArray()
+{
+    color_.release();
 }
 
 void cv::GlArrays::setNormalArray(InputArray normal)
 {
-    int cn = normal.channels();
-    int depth = normal.depth();
+    const int cn = normal.channels();
+    const int depth = normal.depth();
 
-    CV_Assert(cn == 3);
-    CV_Assert(depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F);
+    CV_Assert( cn == 3 );
+    CV_Assert( depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F );
 
-    normal_.copyFrom(normal);
+    if (normal.kind() == _InputArray::OPENGL_BUFFER)
+        normal_ = normal.getGlBuffer();
+    else
+        normal_.copyFrom(normal);
+}
+
+void cv::GlArrays::resetNormalArray()
+{
+    normal_.release();
 }
 
 void cv::GlArrays::setTexCoordArray(InputArray texCoord)
 {
-    int cn = texCoord.channels();
-    int depth = texCoord.depth();
+    const int cn = texCoord.channels();
+    const int depth = texCoord.depth();
 
-    CV_Assert(cn >= 1 && cn <= 4);
-    CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F);
+    CV_Assert( cn >= 1 && cn <= 4 );
+    CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F );
 
-    texCoord_.copyFrom(texCoord);
+    if (texCoord.kind() == _InputArray::OPENGL_BUFFER)
+        texCoord_ = texCoord.getGlBuffer();
+    else
+        texCoord_.copyFrom(texCoord);
+}
+
+void cv::GlArrays::resetTexCoordArray()
+{
+    texCoord_.release();
+}
+
+void cv::GlArrays::release()
+{
+    resetVertexArray();
+    resetColorArray();
+    resetNormalArray();
+    resetTexCoordArray();
+}
+
+void cv::GlArrays::setAutoRelease(bool flag)
+{
+    vertex_.setAutoRelease(flag);
+    color_.setAutoRelease(flag);
+    normal_.setAutoRelease(flag);
+    texCoord_.setAutoRelease(flag);
 }
 
 void cv::GlArrays::bind() const
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    throw_nogl();
 #else
-    CV_DbgAssert(texCoord_.empty() || texCoord_.size().area() == vertex_.size().area());
-    CV_DbgAssert(normal_.empty() || normal_.size().area() == vertex_.size().area());
-    CV_DbgAssert(color_.empty() || color_.size().area() == vertex_.size().area());
+    CV_Assert( texCoord_.empty() || texCoord_.size().area() == size_ );
+    CV_Assert( normal_.empty() || normal_.size().area() == size_ );
+    CV_Assert( color_.empty() || color_.size().area() == size_ );
 
-    if (!texCoord_.empty())
+    if (texCoord_.empty())
     {
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        gl::DisableClientState(gl::TEXTURE_COORD_ARRAY);
         CV_CheckGlError();
-
-        texCoord_.bind();
-
-        glTexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0);
-        CV_CheckGlError();
-
-        texCoord_.unbind();
     }
-
-    if (!normal_.empty())
+    else
     {
-        glEnableClientState(GL_NORMAL_ARRAY);
+        gl::EnableClientState(gl::TEXTURE_COORD_ARRAY);
         CV_CheckGlError();
 
-        normal_.bind();
+        texCoord_.bind(GlBuffer::ARRAY_BUFFER);
 
-        glNormalPointer(gl_types[normal_.depth()], 0, 0);
-        CV_CheckGlError();
-
-        normal_.unbind();
-    }
-
-    if (!color_.empty())
-    {
-        glEnableClientState(GL_COLOR_ARRAY);
-        CV_CheckGlError();
-
-        color_.bind();
-
-        int cn = color_.channels();
-        int format = cn == 3 ? cn : (bgra_ ? GL_BGRA : 4);
-
-        glColorPointer(format, gl_types[color_.depth()], 0, 0);
-        CV_CheckGlError();
-
-        color_.unbind();
-    }
-
-    if (!vertex_.empty())
-    {
-        glEnableClientState(GL_VERTEX_ARRAY);
-        CV_CheckGlError();
-
-        vertex_.bind();
-
-        glVertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0);
-        CV_CheckGlError();
-
-        vertex_.unbind();
-    }
-#endif
-}
-
-void cv::GlArrays::unbind() const
-{
-#ifndef HAVE_OPENGL
-    throw_nogl;
-#else
-    if (!texCoord_.empty())
-    {
-        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        gl::TexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0);
         CV_CheckGlError();
     }
 
-    if (!normal_.empty())
+    if (normal_.empty())
     {
-        glDisableClientState(GL_NORMAL_ARRAY);
+        gl::DisableClientState(gl::NORMAL_ARRAY);
+        CV_CheckGlError();
+    }
+    else
+    {
+        gl::EnableClientState(gl::NORMAL_ARRAY);
+        CV_CheckGlError();
+
+        normal_.bind(GlBuffer::ARRAY_BUFFER);
+
+        gl::NormalPointer(gl_types[normal_.depth()], 0, 0);
         CV_CheckGlError();
     }
 
-    if (!color_.empty())
+    if (color_.empty())
     {
-        glDisableClientState(GL_COLOR_ARRAY);
+        gl::DisableClientState(gl::COLOR_ARRAY);
+        CV_CheckGlError();
+    }
+    else
+    {
+        gl::EnableClientState(gl::COLOR_ARRAY);
+        CV_CheckGlError();
+
+        color_.bind(GlBuffer::ARRAY_BUFFER);
+
+        const int cn = color_.channels();
+
+        gl::ColorPointer(cn, gl_types[color_.depth()], 0, 0);
         CV_CheckGlError();
     }
 
-    if (!vertex_.empty())
+    if (vertex_.empty())
     {
-        glDisableClientState(GL_VERTEX_ARRAY);
+        gl::DisableClientState(gl::VERTEX_ARRAY);
         CV_CheckGlError();
     }
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////
-// GlFont
-
-cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style)
-    : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0)
-{
-#ifndef HAVE_OPENGL
-    throw_nogl;
-#else
-    base_ = glGenLists(256);
-    CV_CheckGlError();
-
-    glFuncTab()->generateBitmapFont(family_, height_, weight_, (style_ & STYLE_ITALIC) != 0, (style_ & STYLE_UNDERLINE) != 0, 0, 256, base_);
-#endif
-}
-
-void cv::GlFont::draw(const char* str, size_t len) const
-{
-#ifndef HAVE_OPENGL
-    (void)str;
-    (void)len;
-    throw_nogl;
-#else
-    if (base_ && len > 0)
+    else
     {
-        glPushAttrib(GL_LIST_BIT);
-        glListBase(base_);
+        gl::EnableClientState(gl::VERTEX_ARRAY);
+        CV_CheckGlError();
 
-        glCallLists(static_cast<GLsizei>(len), GL_UNSIGNED_BYTE, str);
-
-        glPopAttrib();
+        vertex_.bind(GlBuffer::ARRAY_BUFFER);
 
+        gl::VertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0);
         CV_CheckGlError();
     }
-#endif
-}
 
-namespace
-{
-    class FontCompare : public unary_function<Ptr<GlFont>, bool>
-    {
-    public:
-        inline FontCompare(const string& family, int height, GlFont::Weight weight, GlFont::Style style)
-            : family_(family), height_(height), weight_(weight), style_(style)
-        {
-        }
-
-        bool operator ()(const cv::Ptr<GlFont>& font)
-        {
-            return font->family() == family_ && font->height() == height_ && font->weight() == weight_ && font->style() == style_;
-        }
-
-    private:
-        string family_;
-        int height_;
-        GlFont::Weight weight_;
-        GlFont::Style style_;
-    };
-}
-
-Ptr<GlFont> cv::GlFont::get(const std::string& family, int height, Weight weight, Style style)
-{
-#ifndef HAVE_OPENGL
-    (void)family;
-    (void)height;
-    (void)weight;
-    (void)style;
-    throw_nogl;
-    return Ptr<GlFont>();
-#else
-    static vector< Ptr<GlFont> > fonts;
-    fonts.reserve(10);
-
-    vector< Ptr<GlFont> >::iterator fontIt = find_if(fonts.begin(), fonts.end(), FontCompare(family, height, weight, style));
-
-    if (fontIt == fonts.end())
-    {
-        fonts.push_back(new GlFont(family, height, weight, style));
-
-        fontIt = fonts.end() - 1;
-    }
-
-    return *fontIt;
+    GlBuffer::unbind(GlBuffer::ARRAY_BUFFER);
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Rendering
 
-void cv::render(const GlTexture& tex, Rect_<double> wndRect, Rect_<double> texRect)
+void cv::render(const GlTexture2D& tex, Rect_<double> wndRect, Rect_<double> texRect)
 {
 #ifndef HAVE_OPENGL
-    (void)tex;
-    (void)wndRect;
-    (void)texRect;
-    throw_nogl;
+    (void) tex;
+    (void) wndRect;
+    (void) texRect;
+    throw_nogl();
 #else
     if (!tex.empty())
     {
-        tex.bind();
-
-        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-
-        glBegin(GL_QUADS);
-            glTexCoord2d(texRect.x, texRect.y);
-            glVertex2d(wndRect.x, wndRect.y);
-
-            glTexCoord2d(texRect.x, texRect.y + texRect.height);
-            glVertex2d(wndRect.x, (wndRect.y + wndRect.height));
-
-            glTexCoord2d(texRect.x + texRect.width, texRect.y + texRect.height);
-            glVertex2d(wndRect.x + wndRect.width, (wndRect.y + wndRect.height));
-
-            glTexCoord2d(texRect.x + texRect.width, texRect.y);
-            glVertex2d(wndRect.x + wndRect.width, wndRect.y);
-        glEnd();
-
+        gl::MatrixMode(gl::PROJECTION);
+        gl::LoadIdentity();
+        gl::Ortho(0.0, 1.0, 1.0, 0.0, -1.0, 1.0);
         CV_CheckGlError();
 
-        tex.unbind();
+        gl::MatrixMode(gl::MODELVIEW);
+        gl::LoadIdentity();
+        CV_CheckGlError();
+
+        gl::Disable(gl::LIGHTING);
+        CV_CheckGlError();
+
+        tex.bind();
+
+        gl::Enable(gl::TEXTURE_2D);
+        CV_CheckGlError();
+
+        gl::TexEnvi(gl::TEXTURE_ENV, gl::TEXTURE_ENV_MODE, gl::REPLACE);
+        CV_CheckGlError();
+
+        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR);
+        CV_CheckGlError();
+
+        const float vertex[] =
+        {
+            wndRect.x, wndRect.y, 0.0f,
+            wndRect.x, (wndRect.y + wndRect.height), 0.0f,
+            wndRect.x + wndRect.width, (wndRect.y + wndRect.height), 0.0f,
+            wndRect.x + wndRect.width, wndRect.y, 0.0f
+        };
+        const float texCoords[] =
+        {
+            texRect.x, texRect.y,
+            texRect.x, texRect.y + texRect.height,
+            texRect.x + texRect.width, texRect.y + texRect.height,
+            texRect.x + texRect.width, texRect.y
+        };
+
+        GlBuffer::unbind(GlBuffer::ARRAY_BUFFER);
+
+        gl::EnableClientState(gl::TEXTURE_COORD_ARRAY);
+        CV_CheckGlError();
+
+        gl::TexCoordPointer(2, gl::FLOAT, 0, texCoords);
+        CV_CheckGlError();
+
+        gl::DisableClientState(gl::NORMAL_ARRAY);
+        gl::DisableClientState(gl::COLOR_ARRAY);
+        CV_CheckGlError();
+
+        gl::EnableClientState(gl::VERTEX_ARRAY);
+        CV_CheckGlError();
+
+        gl::VertexPointer(3, gl::FLOAT, 0, vertex);
+        CV_CheckGlError();
+
+        gl::DrawArrays(cv::RenderMode::QUADS, 0, 4);
+        CV_CheckGlError();
     }
 #endif
 }
@@ -1376,222 +1476,90 @@ void cv::render(const GlTexture& tex, Rect_<double> wndRect, Rect_<double> texRe
 void cv::render(const GlArrays& arr, int mode, Scalar color)
 {
 #ifndef HAVE_OPENGL
-    (void)arr;
-    (void)mode;
-    (void)color;
-    throw_nogl;
+    (void) arr;
+    (void) mode;
+    (void) color;
+    throw_nogl();
 #else
-    glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
-
-    arr.bind();
-
-    glDrawArrays(mode, 0, arr.size().area());
-
-    arr.unbind();
-#endif
-}
-
-void cv::render(const string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos)
-{
-#ifndef HAVE_OPENGL
-    (void)str;
-    (void)font;
-    (void)color;
-    (void)pos;
-    throw_nogl;
-#else
-    glPushAttrib(GL_DEPTH_BUFFER_BIT);
-
-    GLint viewport[4];
-    glGetIntegerv(GL_VIEWPORT, viewport);
-
-    glDisable(GL_DEPTH_TEST);
-
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-
-    glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
-
-    glRasterPos2d(2.0 * (viewport[0] + pos.x) / viewport[2] - 1.0, 1.0 - 2.0 * (viewport[1] + pos.y + font->height()) / viewport[3]);
-
-    font->draw(str.c_str(), str.length());
-
-    glPopAttrib();
-#endif
-}
-
-////////////////////////////////////////////////////////////////////////
-// GlCamera
-
-cv::GlCamera::GlCamera() :
-    eye_(0.0, 0.0, -5.0), center_(0.0, 0.0, 0.0), up_(0.0, 1.0, 0.0),
-    pos_(0.0, 0.0, -5.0), yaw_(0.0), pitch_(0.0), roll_(0.0),
-    useLookAtParams_(false),
-
-    scale_(1.0, 1.0, 1.0),
-
-    projectionMatrix_(),
-    fov_(45.0), aspect_(0.0),
-    left_(0.0), right_(1.0), bottom_(1.0), top_(0.0),
-    zNear_(-1.0), zFar_(1.0),
-    perspectiveProjection_(false)
-{
-}
-
-void cv::GlCamera::lookAt(Point3d eye, Point3d center, Point3d up)
-{
-    eye_ = eye;
-    center_ = center;
-    up_ = up;
-    useLookAtParams_ = true;
-}
-
-void cv::GlCamera::setCameraPos(Point3d pos, double yaw, double pitch, double roll)
-{
-    pos_ = pos;
-    yaw_ = yaw;
-    pitch_ = pitch;
-    roll_ = roll;
-    useLookAtParams_ = false;
-}
-
-void cv::GlCamera::setScale(Point3d scale)
-{
-    scale_ = scale;
-}
-
-void cv::GlCamera::setProjectionMatrix(const Mat& projectionMatrix, bool transpose)
-{
-    CV_Assert(projectionMatrix.type() == CV_32F || projectionMatrix.type() == CV_64F);
-    CV_Assert(projectionMatrix.cols == 4 && projectionMatrix.rows == 4);
-
-    projectionMatrix_ = transpose ? projectionMatrix.t() : projectionMatrix;
-}
-
-void cv::GlCamera::setPerspectiveProjection(double fov, double aspect, double zNear, double zFar)
-{
-    fov_ = fov;
-    aspect_ = aspect;
-    zNear_ = zNear;
-    zFar_ = zFar;
-
-    projectionMatrix_.release();
-    perspectiveProjection_ = true;
-}
-
-void cv::GlCamera::setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar)
-{
-    left_ = left;
-    right_ = right;
-    bottom_ = bottom;
-    top_ = top;
-    zNear_ = zNear;
-    zFar_ = zFar;
-
-    projectionMatrix_.release();
-    perspectiveProjection_ = false;
-}
-
-void cv::GlCamera::setupProjectionMatrix() const
-{
-#ifndef HAVE_OPENGL
-    throw_nogl;
-#else
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-
-    if (projectionMatrix_.empty())
+    if (!arr.empty())
     {
-        if (perspectiveProjection_)
-            gluPerspective(fov_, aspect_, zNear_, zFar_);
-        else
-            glOrtho(left_, right_, bottom_, top_, zNear_, zFar_);
+        gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
+
+        arr.bind();
+
+        gl::DrawArrays(mode, 0, arr.size());
     }
-    else
-    {
-        if (projectionMatrix_.type() == CV_32F)
-            glLoadMatrixf(projectionMatrix_.ptr<float>());
-        else
-            glLoadMatrixd(projectionMatrix_.ptr<double>());
-    }
-
-    CV_CheckGlError();
 #endif
 }
 
-void cv::GlCamera::setupModelViewMatrix() const
+void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color)
 {
 #ifndef HAVE_OPENGL
-    throw_nogl;
+    (void) arr;
+    (void) indices;
+    (void) mode;
+    (void) color;
+    throw_nogl();
 #else
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-
-    if (useLookAtParams_)
-        gluLookAt(eye_.x, eye_.y, eye_.z, center_.x, center_.y, center_.z, up_.x, up_.y, up_.z);
-    else
+    if (!arr.empty() && !indices.empty())
     {
-        glRotated(-yaw_, 0.0, 1.0, 0.0);
-        glRotated(-pitch_, 1.0, 0.0, 0.0);
-        glRotated(-roll_, 0.0, 0.0, 1.0);
-        glTranslated(-pos_.x, -pos_.y, -pos_.z);
-    }
+        gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
 
-    glScaled(scale_.x, scale_.y, scale_.z);
+        arr.bind();
 
-    CV_CheckGlError();
-#endif
-}
+        const int kind = indices.kind();
 
-////////////////////////////////////////////////////////////////////////
-// Error handling
-
-bool icvCheckGlError(const char* file, const int line, const char* func)
-{
-#ifndef HAVE_OPENGL
-    (void)file;
-    (void)line;
-    (void)func;
-    return true;
-#else
-    GLenum err = glGetError();
-
-    if (err != GL_NO_ERROR)
-    {
-        const char* msg;
-
-        switch (err)
+        switch (kind)
         {
-        case GL_INVALID_ENUM:
-            msg = "An unacceptable value is specified for an enumerated argument";
-            break;
-        case GL_INVALID_VALUE:
-            msg = "A numeric argument is out of range";
-            break;
-        case GL_INVALID_OPERATION:
-            msg = "The specified operation is not allowed in the current state";
-            break;
-        case GL_STACK_OVERFLOW:
-            msg = "This command would cause a stack overflow";
-            break;
-        case GL_STACK_UNDERFLOW:
-            msg = "This command would cause a stack underflow";
-            break;
-        case GL_OUT_OF_MEMORY:
-            msg = "There is not enough memory left to execute the command";
-            break;
+        case _InputArray::OPENGL_BUFFER :
+            {
+                GlBuffer buf = indices.getGlBuffer();
+
+                const int depth = buf.depth();
+
+                CV_Assert( buf.channels() == 1 );
+                CV_Assert( depth <= CV_32S );
+
+                GLenum type;
+                if (depth < CV_16U)
+                    type = gl::UNSIGNED_BYTE;
+                else if (depth < CV_32S)
+                    type = gl::UNSIGNED_SHORT;
+                else
+                    type = gl::UNSIGNED_INT;
+
+                buf.bind(GlBuffer::ELEMENT_ARRAY_BUFFER);
+
+                gl::DrawElements(mode, buf.size().area(), type, 0);
+
+                GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER);
+
+                break;
+            }
+
         default:
-            msg = "Unknown error";
-        };
+            {
+                Mat mat = indices.getMat();
 
-        cvError(CV_OpenGlApiCallError, func, msg, file, line);
+                const int depth = mat.depth();
 
-        return false;
+                CV_Assert( mat.channels() == 1 );
+                CV_Assert( depth <= CV_32S );
+                CV_Assert( mat.isContinuous() );
+
+                GLenum type;
+                if (depth < CV_16U)
+                    type = gl::UNSIGNED_BYTE;
+                else if (depth < CV_32S)
+                    type = gl::UNSIGNED_SHORT;
+                else
+                    type = gl::UNSIGNED_INT;
+
+                GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER);
+
+                gl::DrawElements(mode, mat.size().area(), type, mat.data);
+            }
+        }
     }
-
-    return true;
 #endif
 }
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
new file mode 100644
index 000000000..bbb10e1e3
--- /dev/null
+++ b/modules/gpu/test/test_opengl.cpp
@@ -0,0 +1,625 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#if defined(HAVE_CUDA) && defined(HAVE_OPENGL)
+
+/////////////////////////////////////////////
+// GlBuffer
+
+PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
+{
+    cv::Size size;
+    int type;
+
+    virtual void SetUp()
+    {
+        size = GET_PARAM(0);
+        type = GET_PARAM(1);
+    }
+};
+
+TEST_P(GlBuffer, Constructor1)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlBuffer buf(size.height, size.width, type);
+
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, Constructor2)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlBuffer buf(size, type);
+
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, ConstructorFromMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+
+    cv::GlBuffer buf(gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, ConstructorFromGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
+
+    cv::GlBuffer buf(d_gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    d_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, ConstructorFromGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlBuffer buf_gold(size, type);
+    cv::GlBuffer buf(buf_gold);
+
+    EXPECT_EQ(buf_gold.bufId(), buf.bufId());
+    EXPECT_EQ(buf_gold.rows(), buf.rows());
+    EXPECT_EQ(buf_gold.cols(), buf.cols());
+    EXPECT_EQ(buf_gold.type(), buf.type());
+
+    buf.release();
+    buf_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, ConstructorFromGlTexture2D)
+{
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
+
+    if (depth != CV_32F || cn == 2)
+        return;
+
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold);
+
+    cv::GlBuffer buf(tex_gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+
+    buf.release();
+    tex_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, Create)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlBuffer buf;
+    buf.create(size.height, size.width, type);
+
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyFromMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+
+    cv::GlBuffer buf;
+    buf.copyFrom(gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyFromGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
+
+    cv::GlBuffer buf;
+    buf.copyFrom(d_gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    d_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyFromGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf_gold(gold);
+
+    cv::GlBuffer buf;
+    buf.copyFrom(buf_gold);
+
+    EXPECT_NE(buf_gold.bufId(), buf.bufId());
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    buf_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyFromGlTexture2D)
+{
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
+
+    if (depth != CV_32F || cn == 2)
+        return;
+
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold);
+
+    cv::GlBuffer buf;
+    buf.copyFrom(tex_gold);
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+
+    buf.release();
+    tex_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyToGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+
+    cv::GlBuffer buf(gold);
+    cv::gpu::GpuMat dst;
+    buf.copyTo(dst);
+
+    EXPECT_MAT_NEAR(gold, dst, 0);
+
+    dst.release();
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyToGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer dst;
+    buf.copyTo(dst);
+
+    EXPECT_NE(buf.bufId(), dst.bufId());
+
+    cv::Mat bufData;
+    dst.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    dst.release();
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, CopyToGlTexture2D)
+{
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
+
+    if (depth != CV_32F || cn == 2)
+        return;
+
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlBuffer buf(gold);
+
+    cv::GlTexture2D tex;
+    buf.copyTo(tex);
+
+    cv::Mat texData;
+    tex.copyTo(texData);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, Clone)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer dst = buf.clone();
+
+    EXPECT_NE(buf.bufId(), dst.bufId());
+
+    cv::Mat bufData;
+    dst.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    dst.release();
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, MapHost)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf(gold);
+
+    cv::Mat dst = buf.mapHost();
+
+    EXPECT_MAT_NEAR(gold, dst, 0);
+
+    buf.unmapHost();
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlBuffer, MapDevice)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf(gold);
+
+    cv::gpu::GpuMat dst = buf.mapDevice();
+
+    EXPECT_MAT_NEAR(gold, dst, 0);
+
+    buf.unmapDevice();
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
+INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
+
+/////////////////////////////////////////////
+// GlTexture2D
+
+PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
+{
+    cv::Size size;
+    int type;
+    int depth;
+    int cn;
+    cv::GlTexture2D::Format format;
+
+    virtual void SetUp()
+    {
+        size = GET_PARAM(0);
+        type = GET_PARAM(1);
+
+        depth = CV_MAT_DEPTH(type);
+        cn = CV_MAT_CN(type);
+        format = cn == 1 ? cv::GlTexture2D::DEPTH_COMPONENT : cn == 3 ? cv::GlTexture2D::RGB : cn == 4 ? cv::GlTexture2D::RGBA : cv::GlTexture2D::NONE;
+    }
+};
+
+TEST_P(GlTexture2D, Constructor1)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlTexture2D tex(size.height, size.width, format);
+
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
+
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, Constructor2)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlTexture2D tex(size, format);
+
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
+
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, ConstructorFromMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+
+    cv::GlTexture2D tex(gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, ConstructorFromGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
+
+    cv::GlTexture2D tex(d_gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    d_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, ConstructorFromGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold);
+
+    cv::GlTexture2D tex(buf_gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    buf_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlTexture2D tex_gold(size, format);
+    cv::GlTexture2D tex(tex_gold);
+
+    EXPECT_EQ(tex_gold.texId(), tex.texId());
+    EXPECT_EQ(tex_gold.rows(), tex.rows());
+    EXPECT_EQ(tex_gold.cols(), tex.cols());
+    EXPECT_EQ(tex_gold.format(), tex.format());
+
+    tex.release();
+    tex_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, Create)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::GlTexture2D tex;
+    tex.create(size.height, size.width, format);
+
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
+
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, CopyFromMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+
+    cv::GlTexture2D tex;
+    tex.copyFrom(gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, CopyFromGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
+
+    cv::GlTexture2D tex;
+    tex.copyFrom(d_gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    d_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, CopyFromGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold);
+
+    cv::GlTexture2D tex;
+    tex.copyFrom(buf_gold);
+
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
+
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+
+    tex.release();
+    buf_gold.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, CopyToGpuMat)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+
+    cv::GlTexture2D tex(gold);
+    cv::gpu::GpuMat dst;
+    tex.copyTo(dst, depth);
+
+    EXPECT_MAT_NEAR(gold, dst, 1e-2);
+
+    dst.release();
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+TEST_P(GlTexture2D, CopyToGlBuffer)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+
+    cv::GlTexture2D tex(gold);
+
+    cv::GlBuffer dst;
+    tex.copyTo(dst, depth);
+
+    cv::Mat bufData;
+    dst.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+
+    dst.release();
+    tex.release();
+    cv::destroyAllWindows();
+}
+
+INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
+
+#endif
diff --git a/modules/gpu/test/test_precomp.hpp b/modules/gpu/test/test_precomp.hpp
index b75f8edd8..7eb53d5f3 100644
--- a/modules/gpu/test/test_precomp.hpp
+++ b/modules/gpu/test/test_precomp.hpp
@@ -69,6 +69,7 @@
     #include <cuda_runtime.h>
 
     #include "opencv2/core/core.hpp"
+    #include "opencv2/core/opengl_interop.hpp"
     #include "opencv2/highgui/highgui.hpp"
     #include "opencv2/calib3d/calib3d.hpp"
     #include "opencv2/imgproc/imgproc.hpp"
diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp
index 57aef6314..43cf13dc1 100644
--- a/modules/highgui/include/opencv2/highgui/highgui.hpp
+++ b/modules/highgui/include/opencv2/highgui/highgui.hpp
@@ -125,16 +125,13 @@ CV_EXPORTS_W void setTrackbarPos(const string& trackbarname, const string& winna
 
 // OpenGL support
 
-typedef void (*OpenGlDrawCallback)(void* userdata);
+typedef void (CV_CDECL *OpenGlDrawCallback)(void* userdata);
 CV_EXPORTS void setOpenGlDrawCallback(const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0);
 
 CV_EXPORTS void setOpenGlContext(const string& winname);
 
 CV_EXPORTS void updateWindow(const string& winname);
 
-CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr);
-CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, InputArray points, InputArray colors = noArray());
-
 //Only for Qt
 
 CV_EXPORTS CvFont fontQt(const string& nameFont, int pointSize=-1,
diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp
index 0cef4e77a..9572e3010 100644
--- a/modules/highgui/src/precomp.hpp
+++ b/modules/highgui/src/precomp.hpp
@@ -206,9 +206,6 @@ void cvSetRatioWindow_QT(const char* name,double prop_value);
 double cvGetOpenGlProp_QT(const char* name);
 #endif
 
-// OpenGL
-typedef void (CV_CDECL *CvOpenGlCleanCallback)(void* userdata);
-void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata);
 
 
 /*namespace cv
diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp
index e6b3b1f7a..05cb5ef2e 100644
--- a/modules/highgui/src/window.cpp
+++ b/modules/highgui/src/window.cpp
@@ -40,6 +40,7 @@
 //M*/
 
 #include "precomp.hpp"
+#include <map>
 #include "opencv2/core/opengl_interop.hpp"
 
 // in later times, use this file as a dispatcher to implementations like cvcap.cpp
@@ -240,94 +241,15 @@ void cv::updateWindow(const string& windowName)
 #ifdef HAVE_OPENGL
 namespace
 {
-    const int CV_TEXTURE_MAGIC_VAL        = 0x00287653;
-    const int CV_POINT_CLOUD_MAGIC_VAL    = 0x00287654;
-
-    struct GlObjBase
-    {
-        int flag;
-        GlObjBase* next;
-        GlObjBase* prev;
-        std::string winname;
-
-        virtual ~GlObjBase() {}
-    };
-
-    GlObjBase* g_glObjs = 0;
-
-    GlObjBase* findGlObjByName(const std::string& winname)
-    {
-        GlObjBase* obj = g_glObjs;
-
-        while(obj && obj->winname != winname)
-            obj = obj->next;
-
-        return obj;
-    }
-
-    void addGlObj(GlObjBase* glObj)
-    {
-        glObj->next = g_glObjs;
-        glObj->prev = 0;
-        if (g_glObjs)
-            g_glObjs->prev = glObj;
-        g_glObjs = glObj;
-    }
-
-    void removeGlObj(GlObjBase* glObj)
-    {
-        if (glObj->prev)
-            glObj->prev->next = glObj->next;
-        else
-            g_glObjs = glObj->next;
-
-        if (glObj->next)
-            glObj->next->prev = glObj->prev;
-
-        delete glObj;
-    }
-
-    struct GlObjTex : GlObjBase
-    {
-        cv::GlTexture tex;
-    };
+    std::map<std::string, cv::GlTexture2D> wndTexs;
+    std::map<std::string, cv::GlTexture2D> ownWndTexs;
+    std::map<std::string, cv::GlBuffer> ownWndBufs;
 
     void CV_CDECL glDrawTextureCallback(void* userdata)
     {
-        GlObjTex* texObj = static_cast<GlObjTex*>(userdata);
+        cv::GlTexture2D* texObj = static_cast<cv::GlTexture2D*>(userdata);
 
-        CV_DbgAssert(texObj->flag == CV_TEXTURE_MAGIC_VAL);
-
-        static cv::GlCamera glCamera;
-
-        glCamera.setupProjectionMatrix();
-
-        cv::render(texObj->tex);
-    }
-
-    struct GlObjPointCloud : GlObjBase
-    {
-        cv::GlArrays arr;
-        cv::GlCamera camera;
-    };
-
-    void CV_CDECL glDrawPointCloudCallback(void* userdata)
-    {
-        GlObjPointCloud* pointCloudObj = static_cast<GlObjPointCloud*>(userdata);
-
-        CV_DbgAssert(pointCloudObj->flag == CV_POINT_CLOUD_MAGIC_VAL);
-
-        pointCloudObj->camera.setupProjectionMatrix();
-        pointCloudObj->camera.setupModelViewMatrix();
-
-        cv::render(pointCloudObj->arr);
-    }
-
-    void CV_CDECL glCleanCallback(void* userdata)
-    {
-        GlObjBase* glObj = static_cast<GlObjBase*>(userdata);
-
-        removeGlObj(glObj);
+        cv::render(*texObj);
     }
 }
 #endif // HAVE_OPENGL
@@ -339,7 +261,8 @@ void cv::imshow( const string& winname, InputArray _img )
     CvMat c_img = img;
     cvShowImage(winname.c_str(), &c_img);
 #else
-    double useGl = getWindowProperty(winname, WND_PROP_OPENGL);
+    const double useGl = getWindowProperty(winname, WND_PROP_OPENGL);
+
     if (useGl <= 0)
     {
         Mat img = _img.getMat();
@@ -348,7 +271,7 @@ void cv::imshow( const string& winname, InputArray _img )
     }
     else
     {
-        double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE);
+        const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE);
 
         if (autoSize > 0)
         {
@@ -358,145 +281,44 @@ void cv::imshow( const string& winname, InputArray _img )
 
         setOpenGlContext(winname);
 
-        GlObjBase* glObj = findGlObjByName(winname);
-
-        if (glObj && glObj->flag != CV_TEXTURE_MAGIC_VAL)
+        if (_img.kind() == _InputArray::OPENGL_TEXTURE2D)
         {
-            icvSetOpenGlCleanCallback(winname.c_str(), 0, 0);
-            glObj = 0;
-        }
+            cv::GlTexture2D& tex = wndTexs[winname];
 
-        if (glObj)
-        {
-            GlObjTex* texObj = static_cast<GlObjTex*>(glObj);
-            texObj->tex.copyFrom(_img);
+            tex = _img.getGlTexture2D();
+
+            tex.setAutoRelease(false);
+
+            setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
         }
         else
         {
-            GlObjTex* texObj = new GlObjTex;
-            texObj->tex.copyFrom(_img);
+            cv::GlTexture2D& tex = ownWndTexs[winname];
 
-            glObj = texObj;
-            glObj->flag = CV_TEXTURE_MAGIC_VAL;
-            glObj->winname = winname;
+            if (_img.kind() == _InputArray::GPU_MAT)
+            {
+                cv::GlBuffer& buf = ownWndBufs[winname];
+                buf.copyFrom(_img);
+                buf.setAutoRelease(false);
 
-            addGlObj(glObj);
+                tex.copyFrom(buf);
+                tex.setAutoRelease(false);
+            }
+            else
+            {
+                tex.copyFrom(_img);
+            }
 
-            icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj);
+            tex.setAutoRelease(false);
+
+            setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex);
         }
 
-        setOpenGlDrawCallback(winname, glDrawTextureCallback, glObj);
-
         updateWindow(winname);
     }
 #endif
 }
 
-void cv::pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr)
-{
-#ifndef HAVE_OPENGL
-    CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
-    (void)winname;
-    (void)camera;
-    (void)arr;
-#else
-    namedWindow(winname, WINDOW_OPENGL);
-
-    setOpenGlContext(winname);
-
-    GlObjBase* glObj = findGlObjByName(winname);
-
-    if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL)
-    {
-        icvSetOpenGlCleanCallback(winname.c_str(), 0, 0);
-        glObj = 0;
-    }
-
-    if (glObj)
-    {
-        GlObjPointCloud* pointCloudObj = static_cast<GlObjPointCloud*>(glObj);
-        pointCloudObj->arr = arr;
-        pointCloudObj->camera = camera;
-    }
-    else
-    {
-        GlObjPointCloud* pointCloudObj = new GlObjPointCloud;
-        pointCloudObj->arr = arr;
-        pointCloudObj->camera = camera;
-
-        glObj = pointCloudObj;
-        glObj->flag = CV_POINT_CLOUD_MAGIC_VAL;
-        glObj->winname = winname;
-
-        addGlObj(glObj);
-
-        icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj);
-    }
-
-    setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj);
-
-    updateWindow(winname);
-#endif
-}
-
-void cv::pointCloudShow(const std::string& winname, const cv::GlCamera& camera, InputArray points, InputArray colors)
-{
-#ifndef HAVE_OPENGL
-    (void)winname;
-    (void)camera;
-    (void)points;
-    (void)colors;
-    CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
-#else
-    namedWindow(winname, WINDOW_OPENGL);
-
-    setOpenGlContext(winname);
-
-    GlObjBase* glObj = findGlObjByName(winname);
-
-    if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL)
-    {
-        icvSetOpenGlCleanCallback(winname.c_str(), 0, 0);
-        glObj = 0;
-    }
-
-    if (glObj)
-    {
-        GlObjPointCloud* pointCloudObj = static_cast<GlObjPointCloud*>(glObj);
-
-        pointCloudObj->arr.setVertexArray(points);
-        if (colors.empty())
-            pointCloudObj->arr.resetColorArray();
-        else
-            pointCloudObj->arr.setColorArray(colors);
-
-        pointCloudObj->camera = camera;
-    }
-    else
-    {
-        GlObjPointCloud* pointCloudObj = new GlObjPointCloud;
-
-        pointCloudObj->arr.setVertexArray(points);
-        if (!colors.empty())
-            pointCloudObj->arr.setColorArray(colors);
-
-        pointCloudObj->camera = camera;
-
-        glObj = pointCloudObj;
-        glObj->flag = CV_POINT_CLOUD_MAGIC_VAL;
-        glObj->winname = winname;
-
-        addGlObj(glObj);
-
-        icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj);
-    }
-
-    setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj);
-
-    updateWindow(winname);
-#endif
-}
-
 // Without OpenGL
 
 #ifndef HAVE_OPENGL
@@ -516,11 +338,6 @@ CV_IMPL void cvUpdateWindow(const char*)
     CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
 }
 
-void icvSetOpenGlCleanCallback(const char*, CvOpenGlCleanCallback, void*)
-{
-    CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
-}
-
 #endif // !HAVE_OPENGL
 
 #if defined (HAVE_QT)
diff --git a/modules/highgui/src/window_QT.cpp b/modules/highgui/src/window_QT.cpp
index d617e71f9..2514c2b0c 100644
--- a/modules/highgui/src/window_QT.cpp
+++ b/modules/highgui/src/window_QT.cpp
@@ -685,20 +685,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* window_name, CvOpenGlDrawCallba
 }
 
 
-void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata)
-{
-    if (!guiMainThread)
-        CV_Error( CV_StsNullPtr, "NULL guiReceiver (please create a window)" );
-
-    QMetaObject::invokeMethod(guiMainThread,
-        "setOpenGlCleanCallback",
-        Qt::AutoConnection,
-        Q_ARG(QString, QString(window_name)),
-        Q_ARG(void*, (void*)callback),
-        Q_ARG(void*, userdata));
-}
-
-
 CV_IMPL void cvSetOpenGlContext(const char* window_name)
 {
     if (!guiMainThread)
@@ -1175,14 +1161,6 @@ void GuiReceiver::setOpenGlDrawCallback(QString name, void* callback, void* user
         w->setOpenGlDrawCallback((CvOpenGlDrawCallback) callback, userdata);
 }
 
-void GuiReceiver::setOpenGlCleanCallback(QString name, void* callback, void* userdata)
-{
-    QPointer<CvWindow> w = icvFindWindowByName(name);
-
-    if (w)
-        w->setOpenGlCleanCallback((CvOpenGlCleanCallback) callback, userdata);
-}
-
 void GuiReceiver::setOpenGlContext(QString name)
 {
     QPointer<CvWindow> w = icvFindWindowByName(name);
@@ -1828,12 +1806,6 @@ void CvWindow::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userda
 }
 
 
-void CvWindow::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata)
-{
-    myView->setOpenGlCleanCallback(callback, userdata);
-}
-
-
 void CvWindow::makeCurrentOpenGlContext()
 {
     myView->makeCurrentOpenGlContext();
@@ -2420,12 +2392,6 @@ void DefaultViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback /*callback*/, v
 }
 
 
-void DefaultViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback /*callback*/, void* /*userdata*/)
-{
-    CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL");
-}
-
-
 void DefaultViewPort::makeCurrentOpenGlContext()
 {
     CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL");
@@ -3074,19 +3040,10 @@ OpenGlViewPort::OpenGlViewPort(QWidget* _parent) : QGLWidget(_parent), size(-1,
 
     glDrawCallback = 0;
     glDrawData = 0;
-
-    glCleanCallback = 0;
-    glCleanData = 0;
-
-    glFuncTab = 0;
 }
 
 OpenGlViewPort::~OpenGlViewPort()
 {
-    if (glFuncTab)
-        delete glFuncTab;
-
-    setOpenGlCleanCallback(0, 0);
 }
 
 QWidget* OpenGlViewPort::getWidget()
@@ -3131,21 +3088,9 @@ void OpenGlViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void*
     glDrawData = userdata;
 }
 
-void OpenGlViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata)
-{
-    makeCurrentOpenGlContext();
-
-    if (glCleanCallback)
-        glCleanCallback(glCleanData);
-
-    glCleanCallback = callback;
-    glCleanData = userdata;
-}
-
 void OpenGlViewPort::makeCurrentOpenGlContext()
 {
     makeCurrent();
-    icvSetOpenGlFuncTab(glFuncTab);
 }
 
 void OpenGlViewPort::updateGl()
@@ -3153,255 +3098,9 @@ void OpenGlViewPort::updateGl()
     QGLWidget::updateGL();
 }
 
-#ifndef APIENTRY
-    #define APIENTRY
-#endif
-
-#ifndef APIENTRYP
-    #define APIENTRYP APIENTRY *
-#endif
-
-#ifndef GL_VERSION_1_5
-    /* GL types for handling large vertex buffer objects */
-    typedef ptrdiff_t GLintptr;
-    typedef ptrdiff_t GLsizeiptr;
-#endif
-
-typedef void (APIENTRYP PFNGLGENBUFFERSPROC   ) (GLsizei n, GLuint *buffers);
-typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
-
-typedef void (APIENTRYP PFNGLBUFFERDATAPROC   ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-
-typedef void (APIENTRYP PFNGLBINDBUFFERPROC   ) (GLenum target, GLuint buffer);
-
-typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
-typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target);
-
-class GlFuncTab_QT : public CvOpenGlFuncTab
-{
-public:
-#ifdef Q_WS_WIN
-    GlFuncTab_QT(HDC hDC);
-#else
-    GlFuncTab_QT();
-#endif
-
-    void genBuffers(int n, unsigned int* buffers) const;
-    void deleteBuffers(int n, const unsigned int* buffers) const;
-
-    void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const;
-    void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const;
-
-    void bindBuffer(unsigned int target, unsigned int buffer) const;
-
-    void* mapBuffer(unsigned int target, unsigned int access) const;
-    void unmapBuffer(unsigned int target) const;
-
-    void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const;
-
-    bool isGlContextInitialized() const;
-
-    PFNGLGENBUFFERSPROC    glGenBuffersExt;
-    PFNGLDELETEBUFFERSPROC glDeleteBuffersExt;
-
-    PFNGLBUFFERDATAPROC    glBufferDataExt;
-    PFNGLBUFFERSUBDATAPROC glBufferSubDataExt;
-
-    PFNGLBINDBUFFERPROC    glBindBufferExt;
-
-    PFNGLMAPBUFFERPROC     glMapBufferExt;
-    PFNGLUNMAPBUFFERPROC   glUnmapBufferExt;
-
-    bool initialized;
-
-#ifdef Q_WS_WIN
-    HDC hDC;
-#endif
-};
-
-#ifdef Q_WS_WIN
-    GlFuncTab_QT::GlFuncTab_QT(HDC hDC_) : hDC(hDC_)
-#else
-    GlFuncTab_QT::GlFuncTab_QT()
-#endif
-{
-    glGenBuffersExt    = 0;
-    glDeleteBuffersExt = 0;
-
-    glBufferDataExt    = 0;
-    glBufferSubDataExt = 0;
-
-    glBindBufferExt    = 0;
-
-    glMapBufferExt     = 0;
-    glUnmapBufferExt   = 0;
-
-    initialized = false;
-}
-
-void GlFuncTab_QT::genBuffers(int n, unsigned int* buffers) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::genBuffers" );
-
-    __BEGIN__;
-
-    if (!glGenBuffersExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glGenBuffersExt(n, buffers);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void GlFuncTab_QT::deleteBuffers(int n, const unsigned int* buffers) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::deleteBuffers" );
-
-    __BEGIN__;
-
-    if (!glDeleteBuffersExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glDeleteBuffersExt(n, buffers);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void GlFuncTab_QT::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::bufferData" );
-
-    __BEGIN__;
-
-    if (!glBufferDataExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glBufferDataExt(target, size, data, usage);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void GlFuncTab_QT::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::bufferSubData" );
-
-    __BEGIN__;
-
-    if (!glBufferSubDataExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glBufferSubDataExt(target, offset, size, data);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void GlFuncTab_QT::bindBuffer(unsigned int target, unsigned int buffer) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::bindBuffer" );
-
-    __BEGIN__;
-
-    if (!glBindBufferExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glBindBufferExt(target, buffer);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void* GlFuncTab_QT::mapBuffer(unsigned int target, unsigned int access) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::mapBuffer" );
-
-    void* res = 0;
-
-    __BEGIN__;
-
-    if (!glMapBufferExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    res = glMapBufferExt(target, access);
-    CV_CheckGlError();
-
-    __END__;
-
-    return res;
-}
-
-void GlFuncTab_QT::unmapBuffer(unsigned int target) const
-{
-    CV_FUNCNAME( "GlFuncTab_QT::unmapBuffer" );
-
-    __BEGIN__;
-
-    if (!glUnmapBufferExt)
-        CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-    glUnmapBufferExt(target);
-    CV_CheckGlError();
-
-    __END__;
-}
-
-void GlFuncTab_QT::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const
-{
-#ifdef Q_WS_WIN
-    CV_FUNCNAME( "GlFuncTab_QT::generateBitmapFont" );
-#endif
-
-    QFont font(QString(family.c_str()), height, weight, italic);
-
-    __BEGIN__;
-
-#ifndef Q_WS_WIN
-    font.setStyleStrategy(QFont::OpenGLCompatible);
-    if (font.handle())
-        glXUseXFont(font.handle(), start, count, base);
-#else
-    SelectObject(hDC, font.handle());
-    if (!wglUseFontBitmaps(hDC, start, count, base))
-        CV_ERROR(CV_OpenGlApiCallError, "Can't create font");
-#endif
-
-    __END__;
-}
-
-bool GlFuncTab_QT::isGlContextInitialized() const
-{
-    return initialized;
-}
-
 void OpenGlViewPort::initializeGL()
 {
     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-
-#ifdef Q_WS_WIN
-    std::auto_ptr<GlFuncTab_QT> qglFuncTab(new GlFuncTab_QT(getDC()));
-#else
-    std::auto_ptr<GlFuncTab_QT> qglFuncTab(new GlFuncTab_QT);
-#endif
-
-    // Load extensions
-
-    qglFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)context()->getProcAddress("glGenBuffers");
-    qglFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)context()->getProcAddress("glDeleteBuffers");
-    qglFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)context()->getProcAddress("glBufferData");
-    qglFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)context()->getProcAddress("glBufferSubData");
-    qglFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)context()->getProcAddress("glBindBuffer");
-    qglFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)context()->getProcAddress("glMapBuffer");
-    qglFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)context()->getProcAddress("glUnmapBuffer");
-
-    qglFuncTab->initialized = true;
-
-    glFuncTab = qglFuncTab.release();
-
-    icvSetOpenGlFuncTab(glFuncTab);
 }
 
 void OpenGlViewPort::resizeGL(int w, int h)
@@ -3411,14 +3110,10 @@ void OpenGlViewPort::resizeGL(int w, int h)
 
 void OpenGlViewPort::paintGL()
 {
-    icvSetOpenGlFuncTab(glFuncTab);
-
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     if (glDrawCallback)
         glDrawCallback(glDrawData);
-
-    CV_CheckGlError();
 }
 
 void OpenGlViewPort::mousePressEvent(QMouseEvent* evnt)
diff --git a/modules/highgui/src/window_QT.h b/modules/highgui/src/window_QT.h
index 64faee0f4..1b07442dc 100644
--- a/modules/highgui/src/window_QT.h
+++ b/modules/highgui/src/window_QT.h
@@ -141,7 +141,6 @@ public slots:
     void enablePropertiesButtonEachWindow();
 
     void setOpenGlDrawCallback(QString name, void* callback, void* userdata);
-    void setOpenGlCleanCallback(QString name, void* callback, void* userdata);
     void setOpenGlContext(QString name);
     void updateWindow(QString name);
     double isOpenGl(QString name);
@@ -312,7 +311,6 @@ public:
     static void addSlider2(CvWindow* w, QString name, int* value, int count, CvTrackbarCallback2 on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(0));
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();
     bool isOpenGl();
@@ -397,7 +395,6 @@ public:
     virtual void startDisplayInfo(QString text, int delayms) = 0;
 
     virtual void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata) = 0;
-    virtual void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) = 0;
     virtual void makeCurrentOpenGlContext() = 0;
     virtual void updateGl() = 0;
 
@@ -429,7 +426,6 @@ public:
     void startDisplayInfo(QString text, int delayms);
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();
 
@@ -456,11 +452,6 @@ private:
     CvOpenGlDrawCallback glDrawCallback;
     void* glDrawData;
 
-    CvOpenGlCleanCallback glCleanCallback;
-    void* glCleanData;
-
-    CvOpenGlFuncTab* glFuncTab;
-
     void icvmouseHandler(QMouseEvent* event, type_mouse_event category, int& cv_event, int& flags);
     void icvmouseProcessing(QPointF pt, int cv_event, int flags);
 };
@@ -491,7 +482,6 @@ public:
     void startDisplayInfo(QString text, int delayms);
 
     void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata);
-    void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata);
     void makeCurrentOpenGlContext();
     void updateGl();
 
diff --git a/modules/highgui/src/window_gtk.cpp b/modules/highgui/src/window_gtk.cpp
index 99b16d93c..3ee3d0c48 100644
--- a/modules/highgui/src/window_gtk.cpp
+++ b/modules/highgui/src/window_gtk.cpp
@@ -417,9 +417,6 @@ typedef struct CvWindow
 
     CvOpenGlDrawCallback glDrawCallback;
     void* glDrawData;
-
-    CvOpenGlCleanCallback glCleanCallback;
-    void* glCleanData;
 #endif
 }
 CvWindow;
@@ -692,238 +689,6 @@ double cvGetOpenGlProp_GTK(const char* name)
 
 namespace
 {
-    class GlFuncTab_GTK : public CvOpenGlFuncTab
-    {
-    public:
-        GlFuncTab_GTK();
-
-        void genBuffers(int n, unsigned int* buffers) const;
-        void deleteBuffers(int n, const unsigned int* buffers) const;
-
-        void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const;
-        void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const;
-
-        void bindBuffer(unsigned int target, unsigned int buffer) const;
-
-        void* mapBuffer(unsigned int target, unsigned int access) const;
-        void unmapBuffer(unsigned int target) const;
-
-        void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const;
-
-        bool isGlContextInitialized() const;
-
-        PFNGLGENBUFFERSPROC    glGenBuffersExt;
-        PFNGLDELETEBUFFERSPROC glDeleteBuffersExt;
-
-        PFNGLBUFFERDATAPROC    glBufferDataExt;
-        PFNGLBUFFERSUBDATAPROC glBufferSubDataExt;
-
-        PFNGLBINDBUFFERPROC    glBindBufferExt;
-
-        PFNGLMAPBUFFERPROC     glMapBufferExt;
-        PFNGLUNMAPBUFFERPROC   glUnmapBufferExt;
-
-        bool initialized;
-    };
-
-    GlFuncTab_GTK::GlFuncTab_GTK()
-    {
-        glGenBuffersExt    = 0;
-        glDeleteBuffersExt = 0;
-
-        glBufferDataExt    = 0;
-        glBufferSubDataExt = 0;
-
-        glBindBufferExt    = 0;
-
-        glMapBufferExt     = 0;
-        glUnmapBufferExt   = 0;
-
-        initialized = false;
-    }
-
-    void GlFuncTab_GTK::genBuffers(int n, unsigned int* buffers) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::genBuffers" );
-
-        __BEGIN__;
-
-        if (!glGenBuffersExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glGenBuffersExt(n, buffers);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_GTK::deleteBuffers(int n, const unsigned int* buffers) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::deleteBuffers" );
-
-        __BEGIN__;
-
-        if (!glDeleteBuffersExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glDeleteBuffersExt(n, buffers);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_GTK::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::bufferData" );
-
-        __BEGIN__;
-
-        if (!glBufferDataExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBufferDataExt(target, size, data, usage);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_GTK::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::bufferSubData" );
-
-        __BEGIN__;
-
-        if (!glBufferSubDataExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBufferSubDataExt(target, offset, size, data);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_GTK::bindBuffer(unsigned int target, unsigned int buffer) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::bindBuffer" );
-
-        __BEGIN__;
-
-        if (!glBindBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBindBufferExt(target, buffer);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void* GlFuncTab_GTK::mapBuffer(unsigned int target, unsigned int access) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::mapBuffer" );
-
-        void* res = 0;
-
-        __BEGIN__;
-
-        if (!glMapBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        res = glMapBufferExt(target, access);
-        CV_CheckGlError();
-
-        __END__;
-
-        return res;
-    }
-
-    void GlFuncTab_GTK::unmapBuffer(unsigned int target) const
-    {
-        CV_FUNCNAME( "GlFuncTab_GTK::unmapBuffer" );
-
-        __BEGIN__;
-
-        if (!glUnmapBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glUnmapBufferExt(target);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_GTK::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const
-    {
-        PangoFontDescription* fontDecr;
-        PangoFont* pangoFont;
-
-        CV_FUNCNAME( "GlFuncTab_GTK::generateBitmapFont" );
-
-        __BEGIN__;
-
-        fontDecr = pango_font_description_new();
-
-        pango_font_description_set_size(fontDecr, height);
-
-        pango_font_description_set_family_static(fontDecr, family.c_str());
-
-        pango_font_description_set_weight(fontDecr, static_cast<PangoWeight>(weight));
-
-        pango_font_description_set_style(fontDecr, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL);
-
-        pangoFont = gdk_gl_font_use_pango_font(fontDecr, start, count, base);
-
-        pango_font_description_free(fontDecr);
-
-        if (!pangoFont)
-            CV_ERROR(CV_OpenGlApiCallError, "Can't create font");
-
-        __END__;
-    }
-
-    bool GlFuncTab_GTK::isGlContextInitialized() const
-    {
-        return initialized;
-    }
-
-    void initGl()
-    {
-        static GlFuncTab_GTK glFuncTab;
-        static bool first = true;
-
-        if (first)
-        {
-            // Load extensions
-            GdkGLProc func;
-
-            func = gdk_gl_get_proc_address("glGenBuffers");
-            glFuncTab.glGenBuffersExt = (PFNGLGENBUFFERSPROC)func;
-
-            func = gdk_gl_get_proc_address("glDeleteBuffers");
-            glFuncTab.glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func;
-
-            func = gdk_gl_get_proc_address("glBufferData");
-            glFuncTab.glBufferDataExt = (PFNGLBUFFERDATAPROC)func;
-
-            func = gdk_gl_get_proc_address("glBufferSubData");
-            glFuncTab.glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func;
-
-            func = gdk_gl_get_proc_address("glBindBuffer");
-            glFuncTab.glBindBufferExt = (PFNGLBINDBUFFERPROC)func;
-
-            func = gdk_gl_get_proc_address("glMapBuffer");
-            glFuncTab.glMapBufferExt = (PFNGLMAPBUFFERPROC)func;
-
-            func = gdk_gl_get_proc_address("glUnmapBuffer");
-            glFuncTab.glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func;
-
-            glFuncTab.initialized = true;
-
-            icvSetOpenGlFuncTab(&glFuncTab);
-
-            first = false;
-        }
-    }
-
     void createGlContext(CvWindow* window)
     {
         GdkGLConfig* glconfig;
@@ -932,8 +697,6 @@ namespace
 
         __BEGIN__;
 
-        window->useGl = false;
-
         // Try double-buffered visual
         glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE));
         if (!glconfig)
@@ -943,24 +706,11 @@ namespace
         if (!gtk_widget_set_gl_capability(window->widget, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
             CV_ERROR( CV_OpenGlApiCallError, "Can't Create A GL Device Context" );
 
-        initGl();
-
         window->useGl = true;
 
         __END__;
     }
 
-    void releaseGlContext(CvWindow* window)
-    {
-        //CV_FUNCNAME( "releaseGlContext" );
-
-        //__BEGIN__;
-
-        window->useGl = false;
-
-        //__END__;
-    }
-
     void drawGl(CvWindow* window)
     {
         CV_FUNCNAME( "drawGl" );
@@ -980,8 +730,6 @@ namespace
         if (window->glDrawCallback)
             window->glDrawCallback(window->glDrawData);
 
-        CV_CheckGlError();
-
         if (gdk_gl_drawable_is_double_buffered (gldrawable))
             gdk_gl_drawable_swap_buffers(gldrawable);
         else
@@ -1101,9 +849,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags )
 
     window->glDrawCallback = 0;
     window->glDrawData = 0;
-
-    window->glCleanCallback = 0;
-    window->glCleanData = 0;
 #endif
 
     //
@@ -1233,40 +978,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call
     __END__;
 }
 
-void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata)
-{
-    CvWindow* window;
-    GdkGLContext* glcontext;
-    GdkGLDrawable* gldrawable;
-
-    CV_FUNCNAME( "icvSetOpenGlCleanCallback" );
-
-    __BEGIN__;
-
-    if (!name)
-        CV_ERROR(CV_StsNullPtr, "NULL name string");
-
-    window = icvFindWindowByName(name);
-    if (!window)
-        EXIT;
-
-    if (!window->useGl)
-        CV_ERROR( CV_OpenGlNotSupported, "Window doesn't support OpenGL" );
-
-    glcontext = gtk_widget_get_gl_context(window->widget);
-    gldrawable = gtk_widget_get_gl_drawable(window->widget);
-
-    gdk_gl_drawable_make_current(gldrawable, glcontext);
-
-    if (window->glCleanCallback)
-        window->glCleanCallback(window->glCleanData);
-
-    window->glCleanCallback = callback;
-    window->glCleanData = userdata;
-
-    __END__;
-}
-
 #endif // HAVE_OPENGL
 
 
@@ -1276,25 +987,6 @@ static void icvDeleteWindow( CvWindow* window )
 {
     CvTrackbar* trackbar;
 
-#ifdef HAVE_OPENGL
-    if (window->useGl)
-    {
-        GdkGLContext* glcontext = gtk_widget_get_gl_context(window->widget);
-        GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable(window->widget);
-
-        gdk_gl_drawable_make_current(gldrawable, glcontext);
-
-        if (window->glCleanCallback)
-        {
-            window->glCleanCallback(window->glCleanData);
-            window->glCleanCallback = 0;
-            window->glCleanData = 0;
-        }
-
-        releaseGlContext(window);
-    }
-#endif
-
     if( window->prev )
         window->prev->next = window->next;
     else
diff --git a/modules/highgui/src/window_w32.cpp b/modules/highgui/src/window_w32.cpp
index 348420afd..094819740 100644
--- a/modules/highgui/src/window_w32.cpp
+++ b/modules/highgui/src/window_w32.cpp
@@ -192,11 +192,6 @@ typedef struct CvWindow
 
     CvOpenGlDrawCallback glDrawCallback;
     void* glDrawData;
-
-    CvOpenGlCleanCallback glCleanCallback;
-    void* glCleanData;
-
-    CvOpenGlFuncTab* glFuncTab;
 #endif
 }
 CvWindow;
@@ -580,272 +575,8 @@ double cvGetOpenGlProp_W32(const char* name)
 
 #ifdef HAVE_OPENGL
 
-#ifndef APIENTRY
-    #define APIENTRY
-#endif
-
-#ifndef APIENTRYP
-    #define APIENTRYP APIENTRY *
-#endif
-
-#ifndef GL_VERSION_1_5
-    /* GL types for handling large vertex buffer objects */
-    typedef ptrdiff_t GLintptr;
-    typedef ptrdiff_t GLsizeiptr;
-#endif
-
 namespace
 {
-    typedef void (APIENTRYP PFNGLGENBUFFERSPROC   ) (GLsizei n, GLuint *buffers);
-    typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
-
-    typedef void (APIENTRYP PFNGLBUFFERDATAPROC   ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
-
-    typedef void (APIENTRYP PFNGLBINDBUFFERPROC   ) (GLenum target, GLuint buffer);
-
-    typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access);
-    typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target);
-
-    class GlFuncTab_W32 : public CvOpenGlFuncTab
-    {
-    public:
-        GlFuncTab_W32(HDC hDC);
-
-        void genBuffers(int n, unsigned int* buffers) const;
-        void deleteBuffers(int n, const unsigned int* buffers) const;
-
-        void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const;
-        void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const;
-
-        void bindBuffer(unsigned int target, unsigned int buffer) const;
-
-        void* mapBuffer(unsigned int target, unsigned int access) const;
-        void unmapBuffer(unsigned int target) const;
-
-        void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const;
-
-        bool isGlContextInitialized() const;
-
-        PFNGLGENBUFFERSPROC    glGenBuffersExt;
-        PFNGLDELETEBUFFERSPROC glDeleteBuffersExt;
-
-        PFNGLBUFFERDATAPROC    glBufferDataExt;
-        PFNGLBUFFERSUBDATAPROC glBufferSubDataExt;
-
-        PFNGLBINDBUFFERPROC    glBindBufferExt;
-
-        PFNGLMAPBUFFERPROC     glMapBufferExt;
-        PFNGLUNMAPBUFFERPROC   glUnmapBufferExt;
-
-        bool initialized;
-
-        HDC hDC;
-    };
-
-    GlFuncTab_W32::GlFuncTab_W32(HDC hDC_)
-    {
-        glGenBuffersExt    = 0;
-        glDeleteBuffersExt = 0;
-
-        glBufferDataExt    = 0;
-        glBufferSubDataExt = 0;
-
-        glBindBufferExt    = 0;
-
-        glMapBufferExt     = 0;
-        glUnmapBufferExt   = 0;
-
-        initialized = false;
-
-        hDC = hDC_;
-    }
-
-    void GlFuncTab_W32::genBuffers(int n, unsigned int* buffers) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::genBuffers" );
-
-        __BEGIN__;
-
-        if (!glGenBuffersExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glGenBuffersExt(n, buffers);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_W32::deleteBuffers(int n, const unsigned int* buffers) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::deleteBuffers" );
-
-        __BEGIN__;
-
-        if (!glDeleteBuffersExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glDeleteBuffersExt(n, buffers);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_W32::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::bufferData" );
-
-        __BEGIN__;
-
-        if (!glBufferDataExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBufferDataExt(target, size, data, usage);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_W32::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::bufferSubData" );
-
-        __BEGIN__;
-
-        if (!glBufferSubDataExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBufferSubDataExt(target, offset, size, data);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_W32::bindBuffer(unsigned int target, unsigned int buffer) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::bindBuffer" );
-
-        __BEGIN__;
-
-        if (!glBindBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glBindBufferExt(target, buffer);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void* GlFuncTab_W32::mapBuffer(unsigned int target, unsigned int access) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::mapBuffer" );
-
-        void* res = 0;
-
-        __BEGIN__;
-
-        if (!glMapBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        res = glMapBufferExt(target, access);
-        CV_CheckGlError();
-
-        __END__;
-
-        return res;
-    }
-
-    void GlFuncTab_W32::unmapBuffer(unsigned int target) const
-    {
-        CV_FUNCNAME( "GlFuncTab_W32::unmapBuffer" );
-
-        __BEGIN__;
-
-        if (!glUnmapBufferExt)
-            CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension");
-
-        glUnmapBufferExt(target);
-        CV_CheckGlError();
-
-        __END__;
-    }
-
-    void GlFuncTab_W32::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const
-    {
-        HFONT font;
-
-        CV_FUNCNAME( "GlFuncTab_W32::generateBitmapFont" );
-
-        __BEGIN__;
-
-        font = CreateFont
-        (
-            -height,                     // height
-            0,                           // cell width
-            0,                           // Angle of Escapement
-            0,                           // Orientation Angle
-            weight,                      // font weight
-            italic ? TRUE : FALSE,       // Italic
-            underline ? TRUE : FALSE,    // Underline
-            FALSE,                       // StrikeOut
-            ANSI_CHARSET,                // CharSet
-            OUT_TT_PRECIS,               // OutPrecision
-            CLIP_DEFAULT_PRECIS,         // ClipPrecision
-            ANTIALIASED_QUALITY,         // Quality
-            FF_DONTCARE | DEFAULT_PITCH, // PitchAndFamily
-            family.c_str()               // FaceName
-        );
-
-        SelectObject(hDC, font);
-
-        if (!wglUseFontBitmaps(hDC, start, count, base))
-            CV_ERROR(CV_OpenGlApiCallError, "Can't create font");
-
-        __END__;
-    }
-
-    bool GlFuncTab_W32::isGlContextInitialized() const
-    {
-        return initialized;
-    }
-
-    void initGl(CvWindow* window)
-    {
-        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
-
-        std::auto_ptr<GlFuncTab_W32> glFuncTab(new GlFuncTab_W32(window->dc));
-
-        // Load extensions
-        PROC func;
-
-        func = wglGetProcAddress("glGenBuffers");
-        glFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)func;
-
-        func = wglGetProcAddress("glDeleteBuffers");
-        glFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func;
-
-        func = wglGetProcAddress("glBufferData");
-        glFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)func;
-
-        func = wglGetProcAddress("glBufferSubData");
-        glFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func;
-
-        func = wglGetProcAddress("glBindBuffer");
-        glFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)func;
-
-        func = wglGetProcAddress("glMapBuffer");
-        glFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)func;
-
-        func = wglGetProcAddress("glUnmapBuffer");
-        glFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func;
-
-        glFuncTab->initialized = true;
-
-        window->glFuncTab = glFuncTab.release();
-
-        icvSetOpenGlFuncTab(window->glFuncTab);
-    }
-
     void createGlContext(HWND hWnd, HDC& hGLDC, HGLRC& hGLRC, bool& useGl)
     {
         CV_FUNCNAME( "createGlContext" );
@@ -907,8 +638,6 @@ namespace
 
         __BEGIN__;
 
-        delete window->glFuncTab;
-
         if (window->hGLRC)
         {
             wglDeleteContext(window->hGLRC);
@@ -940,8 +669,6 @@ namespace
         if (window->glDrawCallback)
             window->glDrawCallback(window->glDrawData);
 
-        CV_CheckGlError();
-
         if (!SwapBuffers(window->dc))
             CV_ERROR( CV_OpenGlApiCallError, "Can't swap OpenGL buffers" );
 
@@ -1042,7 +769,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags )
 #ifndef HAVE_OPENGL
     window->dc = CreateCompatibleDC(0);
 #else
-    window->glFuncTab = 0;
     if (!useGl)
     {
         window->dc = CreateCompatibleDC(0);
@@ -1054,14 +780,10 @@ CV_IMPL int cvNamedWindow( const char* name, int flags )
         window->dc = hGLDC;
         window->hGLRC = hGLRC;
         window->useGl = true;
-        initGl(window);
     }
 
     window->glDrawCallback = 0;
     window->glDrawData = 0;
-
-    window->glCleanCallback = 0;
-    window->glCleanData = 0;
 #endif
 
     window->last_key = 0;
@@ -1112,8 +834,6 @@ CV_IMPL void cvSetOpenGlContext(const char* name)
     if (!wglMakeCurrent(window->dc, window->hGLRC))
         CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
 
-    icvSetOpenGlFuncTab(window->glFuncTab);
-
     __END__;
 }
 
@@ -1161,30 +881,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call
     __END__;
 }
 
-void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata)
-{
-    CV_FUNCNAME( "icvSetOpenGlCleanCallback" );
-
-    __BEGIN__;
-
-    CvWindow* window;
-
-    if (!name)
-        CV_ERROR(CV_StsNullPtr, "NULL name string");
-
-    window = icvFindWindowByName(name);
-    if (!window)
-        EXIT;
-
-    if (window->glCleanCallback)
-        window->glCleanCallback(window->glCleanData);
-
-    window->glCleanCallback = callback;
-    window->glCleanData = userdata;
-
-    __END__;
-}
-
 #endif // HAVE_OPENGL
 
 static void icvRemoveWindow( CvWindow* window )
@@ -1194,18 +890,7 @@ static void icvRemoveWindow( CvWindow* window )
 
 #ifdef HAVE_OPENGL
     if (window->useGl)
-    {
-        wglMakeCurrent(window->dc, window->hGLRC);
-
-        if (window->glCleanCallback)
-        {
-            window->glCleanCallback(window->glCleanData);
-            window->glCleanCallback = 0;
-            window->glCleanData = 0;
-        }
-
         releaseGlContext(window);
-    }
 #endif
 
     if( window->frame )
diff --git a/samples/cpp/point_cloud.cpp b/samples/cpp/point_cloud.cpp
deleted file mode 100644
index 3672de142..000000000
--- a/samples/cpp/point_cloud.cpp
+++ /dev/null
@@ -1,357 +0,0 @@
-#include <cstring>
-#include <cmath>
-#include <iostream>
-#include <sstream>
-#include "opencv2/core/core.hpp"
-#include "opencv2/core/opengl_interop.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/contrib/contrib.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
-
-class PointCloudRenderer
-{
-public:
-    PointCloudRenderer(const Mat& points, const Mat& img, double scale);
-
-    void onMouseEvent(int event, int x, int y, int flags);
-    void draw();
-    void update(int key, double aspect);
-
-    int fov_;
-
-private:
-    int mouse_dx_;
-    int mouse_dy_;
-
-    double yaw_;
-    double pitch_;
-    Point3d pos_;
-
-    TickMeter tm_;
-    static const int step_;
-    int frame_;
-
-    GlCamera camera_;
-    GlArrays pointCloud_;
-    string fps_;
-};
-
-bool stop = false;
-
-static void mouseCallback(int event, int x, int y, int flags, void* userdata)
-{
-    if (stop)
-        return;
-
-    PointCloudRenderer* renderer = static_cast<PointCloudRenderer*>(userdata);
-    renderer->onMouseEvent(event, x, y, flags);
-}
-
-static void openGlDrawCallback(void* userdata)
-{
-    if (stop)
-        return;
-
-    PointCloudRenderer* renderer = static_cast<PointCloudRenderer*>(userdata);
-    renderer->draw();
-}
-
-int main(int argc, const char* argv[])
-{
-    const char* keys =
-       "{ l left      |       | left image file name }"
-       "{ r right     |       | right image file name }"
-       "{ i intrinsic |       | intrinsic camera parameters file name }"
-       "{ e extrinsic |       | extrinsic camera parameters file name }"
-       "{ d ndisp     | 256   | number of disparities }"
-       "{ s scale     | 1.0   | scale factor for point cloud }"
-       "{ h help      |       | print help message }";
-
-    CommandLineParser cmd(argc, argv, keys);
-
-    if (cmd.has("help"))
-    {
-        cmd.printMessage();
-        return 0;
-    }
-
-    string left = cmd.get<string>("left");
-    string right = cmd.get<string>("right");
-    string intrinsic = cmd.get<string>("intrinsic");
-    string extrinsic = cmd.get<string>("extrinsic");
-    int ndisp = cmd.get<int>("ndisp");
-    double scale = cmd.get<double>("scale");
-
-    if (!cmd.check())
-    {
-        cmd.printErrors();
-        return 0;
-    }
-
-
-    if (left.empty() || right.empty())
-    {
-        cout << "Missed input images" << endl;
-        cout << "Avaible options:" << endl;
-        cmd.printMessage();
-        return 0;
-    }
-
-    if (intrinsic.empty() ^ extrinsic.empty())
-    {
-        cout << "Boss camera parameters must be specified" << endl;
-        cout << "Avaible options:" << endl;
-        cmd.printMessage();
-        return 0;
-    }
-
-    Mat imgLeftColor = imread(left, IMREAD_COLOR);
-    Mat imgRightColor = imread(right, IMREAD_COLOR);
-
-    if (imgLeftColor.empty())
-    {
-        cout << "Can't load image " << left << endl;
-        return -1;
-    }
-
-    if (imgRightColor.empty())
-    {
-        cout << "Can't load image " << right << endl;
-        return -1;
-    }
-
-    Mat Q = Mat::eye(4, 4, CV_32F);
-    if (!intrinsic.empty() && !extrinsic.empty())
-    {
-        FileStorage fs;
-
-        // reading intrinsic parameters
-        fs.open(intrinsic, CV_STORAGE_READ);
-        if (!fs.isOpened())
-        {
-            cout << "Failed to open file " << intrinsic << endl;
-            return -1;
-        }
-
-        Mat M1, D1, M2, D2;
-        fs["M1"] >> M1;
-        fs["D1"] >> D1;
-        fs["M2"] >> M2;
-        fs["D2"] >> D2;
-
-        // reading extrinsic parameters
-        fs.open(extrinsic, CV_STORAGE_READ);
-        if (!fs.isOpened())
-        {
-            cout << "Failed to open file " << extrinsic << endl;
-            return -1;
-        }
-
-        Mat R, T, R1, P1, R2, P2;
-        fs["R"] >> R;
-        fs["T"] >> T;
-
-        Size img_size = imgLeftColor.size();
-
-        Rect roi1, roi2;
-        stereoRectify(M1, D1, M2, D2, img_size, R, T, R1, R2, P1, P2, Q, CALIB_ZERO_DISPARITY, -1, img_size, &roi1, &roi2);
-
-        Mat map11, map12, map21, map22;
-        initUndistortRectifyMap(M1, D1, R1, P1, img_size, CV_16SC2, map11, map12);
-        initUndistortRectifyMap(M2, D2, R2, P2, img_size, CV_16SC2, map21, map22);
-
-        Mat img1r, img2r;
-        remap(imgLeftColor, img1r, map11, map12, INTER_LINEAR);
-        remap(imgRightColor, img2r, map21, map22, INTER_LINEAR);
-
-        imgLeftColor = img1r(roi1);
-        imgRightColor = img2r(roi2);
-    }
-
-    Mat imgLeftGray, imgRightGray;
-    cvtColor(imgLeftColor, imgLeftGray, COLOR_BGR2GRAY);
-    cvtColor(imgRightColor, imgRightGray, COLOR_BGR2GRAY);
-
-    cvtColor(imgLeftColor, imgLeftColor, COLOR_BGR2RGB);
-
-    Mat disp, points;
-
-    StereoBM bm(0, ndisp);
-
-    bm(imgLeftGray, imgRightGray, disp);
-    disp.convertTo(disp, CV_8U, 1.0 / 16.0);
-
-    disp = disp(Range(21, disp.rows - 21), Range(ndisp, disp.cols - 21)).clone();
-    imgLeftColor = imgLeftColor(Range(21, imgLeftColor.rows - 21), Range(ndisp, imgLeftColor.cols - 21)).clone();
-
-    reprojectImageTo3D(disp, points, Q);
-
-    const string windowName = "OpenGL Sample";
-
-    namedWindow(windowName, WINDOW_OPENGL);
-    resizeWindow(windowName, 400, 400);
-
-    PointCloudRenderer renderer(points, imgLeftColor, scale);
-
-    createTrackbar("Fov", windowName, &renderer.fov_, 100);
-    setMouseCallback(windowName, mouseCallback, &renderer);
-    setOpenGlDrawCallback(windowName, openGlDrawCallback, &renderer);
-
-    for(;;)
-    {
-        int key = waitKey(10);
-
-        if (key >= 0)
-            key = key & 0xff;
-
-        if (key == 27)
-        {
-            stop = true;
-            break;
-        }
-
-        double aspect = getWindowProperty(windowName, WND_PROP_ASPECT_RATIO);
-
-        key = tolower(key);
-
-        renderer.update(key, aspect);
-
-        updateWindow(windowName);
-    }
-
-    return 0;
-}
-
-const int PointCloudRenderer::step_ = 20;
-
-PointCloudRenderer::PointCloudRenderer(const Mat& points, const Mat& img, double scale)
-{
-    mouse_dx_ = 0;
-    mouse_dy_ = 0;
-
-    fov_ = 0;
-    yaw_ = 0.0;
-    pitch_ = 0.0;
-
-    frame_ = 0;
-
-    camera_.setScale(Point3d(scale, scale, scale));
-
-    pointCloud_.setVertexArray(points);
-    pointCloud_.setColorArray(img, false);
-
-    tm_.start();
-}
-
-inline int clamp(int val, int minVal, int maxVal)
-{
-    return max(min(val, maxVal), minVal);
-}
-
-void PointCloudRenderer::onMouseEvent(int event, int x, int y, int /*flags*/)
-{
-    static int oldx = x;
-    static int oldy = y;
-    static bool moving = false;
-
-    if (event == EVENT_LBUTTONDOWN)
-    {
-        oldx = x;
-        oldy = y;
-        moving = true;
-    }
-    else if (event == EVENT_LBUTTONUP)
-    {
-        moving = false;
-    }
-
-    if (moving)
-    {
-        mouse_dx_ = oldx - x;
-        mouse_dy_ = oldy - y;
-    }
-    else
-    {
-        mouse_dx_ = 0;
-        mouse_dy_ = 0;
-    }
-
-    const int mouseClamp = 300;
-    mouse_dx_ = clamp(mouse_dx_, -mouseClamp, mouseClamp);
-    mouse_dy_ = clamp(mouse_dy_, -mouseClamp, mouseClamp);
-}
-
-static Point3d rotate(Point3d v, double yaw, double pitch)
-{
-    Point3d t1;
-    t1.x = v.x * cos(-yaw / 180.0 * CV_PI) - v.z * sin(-yaw / 180.0 * CV_PI);
-    t1.y = v.y;
-    t1.z = v.x * sin(-yaw / 180.0 * CV_PI) + v.z * cos(-yaw / 180.0 * CV_PI);
-
-    Point3d t2;
-    t2.x = t1.x;
-    t2.y = t1.y * cos(pitch / 180.0 * CV_PI) - t1.z * sin(pitch / 180.0 * CV_PI);
-    t2.z = t1.y * sin(pitch / 180.0 * CV_PI) + t1.z * cos(pitch / 180.0 * CV_PI);
-
-    return t2;
-}
-
-void PointCloudRenderer::update(int key, double aspect)
-{
-    const Point3d dirVec(0.0, 0.0, -1.0);
-    const Point3d upVec(0.0, 1.0, 0.0);
-    const Point3d leftVec(-1.0, 0.0, 0.0);
-
-    const double posStep = 0.1;
-
-    const double mouseStep = 0.001;
-
-    camera_.setPerspectiveProjection(30.0 + fov_ / 100.0 * 40.0, aspect, 0.1, 1000.0);
-
-    yaw_ += mouse_dx_ * mouseStep;
-    pitch_ += mouse_dy_ * mouseStep;
-
-    if (key == 'w')
-        pos_ += posStep * rotate(dirVec, yaw_, pitch_);
-    else if (key == 's')
-        pos_ -= posStep * rotate(dirVec, yaw_, pitch_);
-    else if (key == 'a')
-        pos_ += posStep * rotate(leftVec, yaw_, pitch_);
-    else if (key == 'd')
-        pos_ -= posStep * rotate(leftVec, yaw_, pitch_);
-    else if (key == 'q')
-        pos_ += posStep * rotate(upVec, yaw_, pitch_);
-    else if (key == 'e')
-        pos_ -= posStep * rotate(upVec, yaw_, pitch_);
-
-    camera_.setCameraPos(pos_, yaw_, pitch_, 0.0);
-
-    tm_.stop();
-
-    if (frame_++ >= step_)
-    {
-        ostringstream ostr;
-        ostr << "FPS: " << step_ / tm_.getTimeSec();
-        fps_ = ostr.str();
-
-        frame_ = 0;
-        tm_.reset();
-    }
-
-    tm_.start();
-}
-
-void PointCloudRenderer::draw()
-{
-    camera_.setupProjectionMatrix();
-    camera_.setupModelViewMatrix();
-
-    render(pointCloud_);
-
-    render(fps_, GlFont::get("Courier New", 16), Scalar::all(255), Point2d(3.0, 0.0));
-}
diff --git a/samples/gpu/brox_optical_flow.cpp b/samples/gpu/brox_optical_flow.cpp
index b25e38a9f..143d0b485 100644
--- a/samples/gpu/brox_optical_flow.cpp
+++ b/samples/gpu/brox_optical_flow.cpp
@@ -4,7 +4,6 @@
 
 #include "cvconfig.h"
 #include "opencv2/core/core.hpp"
-#include "opencv2/core/opengl_interop.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/gpu/gpu.hpp"
 
@@ -14,12 +13,6 @@ using namespace cv::gpu;
 
 void getFlowField(const Mat& u, const Mat& v, Mat& flowField);
 
-#ifdef HAVE_OPENGL
-
-void needleMapDraw(void* userdata);
-
-#endif
-
 int main(int argc, const char* argv[])
 {
     try
@@ -79,12 +72,8 @@ int main(int argc, const char* argv[])
         namedWindow("Forward flow");
         namedWindow("Backward flow");
 
-        namedWindow("Needle Map", WINDOW_OPENGL);
-
         namedWindow("Interpolated frame");
 
-        setGlDevice();
-
         cout << "Press:" << endl;
         cout << "\tESC to quit" << endl;
         cout << "\t'a' to move to the previous frame" << endl;
@@ -123,14 +112,6 @@ int main(int argc, const char* argv[])
         Mat flowFieldBackward;
         getFlowField(Mat(d_bu), Mat(d_bv), flowFieldBackward);
 
-#ifdef HAVE_OPENGL
-        cout << "Create Optical Flow Needle Map..." << endl;
-
-        GpuMat d_vertex, d_colors;
-
-        createOpticalFlowNeedleMap(d_fu, d_fv, d_vertex, d_colors);
-#endif
-
         cout << "Interpolating..." << endl;
 
         // first frame color components
@@ -195,14 +176,6 @@ int main(int argc, const char* argv[])
         imshow("Forward flow", flowFieldForward);
         imshow("Backward flow", flowFieldBackward);
 
-#ifdef HAVE_OPENGL
-        GlArrays arr;
-        arr.setVertexArray(d_vertex);
-        arr.setColorArray(d_colors, false);
-
-        setOpenGlDrawCallback("Needle Map", needleMapDraw, &arr);
-#endif
-
         int currentFrame = 0;
 
         imshow("Interpolated frame", frames[currentFrame]);
@@ -292,21 +265,3 @@ void getFlowField(const Mat& u, const Mat& v, Mat& flowField)
         }
     }
 }
-
-#ifdef HAVE_OPENGL
-
-void needleMapDraw(void* userdata)
-{
-    const GlArrays* arr = static_cast<const GlArrays*>(userdata);
-
-    GlCamera camera;
-    camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
-    camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0));
-
-    camera.setupProjectionMatrix();
-    camera.setupModelViewMatrix();
-
-    render(*arr, RenderMode::TRIANGLES);
-}
-
-#endif
diff --git a/samples/gpu/highgui_gpu.cpp b/samples/gpu/highgui_gpu.cpp
deleted file mode 100644
index 368a6f608..000000000
--- a/samples/gpu/highgui_gpu.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include <iostream>
-#include <string>
-
-#include "opencv2/core/core.hpp"
-#include "opencv2/core/gpumat.hpp"
-#include "opencv2/core/opengl_interop.hpp"
-#include "opencv2/gpu/gpu.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/contrib/contrib.hpp"
-
-using namespace std;
-using namespace cv;
-using namespace cv::gpu;
-
-struct Timer
-{
-    Timer(const string& msg_)
-    {
-        msg = msg_;
-
-        tm.reset();
-        tm.start();
-    }
-
-    ~Timer()
-    {
-        tm.stop();
-        cout << msg << " " << tm.getTimeMilli() << " ms\n";
-    }
-
-    string msg;
-    TickMeter tm;
-};
-
-int main(int argc, char* argv[])
-{
-    if (argc < 2)
-    {
-        cout << "Usage: " << argv[0] << " image" << endl;
-        return -1;
-    }
-
-    try
-    {
-        bool haveCuda = getCudaEnabledDeviceCount() > 0;
-
-        const string openGlMatWnd = "OpenGL Mat";
-        const string openGlBufferWnd = "OpenGL GlBuffer";
-        const string openGlTextureWnd = "OpenGL GlTexture";
-        const string openGlGpuMatWnd = "OpenGL GpuMat";
-        const string matWnd = "Mat";
-
-        namedWindow(openGlMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE);
-        namedWindow(openGlBufferWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE);
-        namedWindow(openGlTextureWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE);
-        if (haveCuda)
-            namedWindow(openGlGpuMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE);
-        namedWindow("Mat", WINDOW_AUTOSIZE);
-
-        Mat img = imread(argv[1]);
-
-        if (haveCuda)
-            setGlDevice();
-
-        setOpenGlContext(openGlBufferWnd);
-        GlBuffer buf(img, GlBuffer::TEXTURE_BUFFER);
-
-        setOpenGlContext(openGlTextureWnd);
-        GlTexture tex(img);
-
-        GpuMat d_img;
-        if (haveCuda)
-            d_img.upload(img);
-
-        cout << "=== First call\n\n";
-
-        {
-            Timer t("OpenGL Mat      ");
-            imshow(openGlMatWnd, img);
-        }
-        {
-            Timer t("OpenGL GlBuffer ");
-            imshow(openGlBufferWnd, buf);
-        }
-        {
-            Timer t("OpenGL GlTexture");
-            imshow(openGlTextureWnd, tex);
-        }
-        if (haveCuda)
-        {
-            Timer t("OpenGL GpuMat   ");
-            imshow(openGlGpuMatWnd, d_img);
-        }
-        {
-            Timer t("Mat             ");
-            imshow(matWnd, img);
-        }
-
-        waitKey();
-
-        cout << "\n=== Second call\n\n";
-
-        {
-            Timer t("OpenGL Mat      ");
-            imshow(openGlMatWnd, img);
-        }
-        {
-            Timer t("OpenGL GlBuffer ");
-            imshow(openGlBufferWnd, buf);
-        }
-        {
-            Timer t("OpenGL GlTexture");
-            imshow(openGlTextureWnd, tex);
-        }
-        if (haveCuda)
-        {
-            Timer t("OpenGL GpuMat   ");
-            imshow(openGlGpuMatWnd, d_img);
-        }
-        {
-            Timer t("Mat             ");
-            imshow(matWnd, img);
-        }
-
-        cout << "\n";
-
-        waitKey();
-    }
-    catch(const exception& e)
-    {
-        cout << e.what() << endl;
-    }
-
-    return 0;
-}
diff --git a/samples/gpu/opengl.cpp b/samples/gpu/opengl.cpp
new file mode 100644
index 000000000..acd59e294
--- /dev/null
+++ b/samples/gpu/opengl.cpp
@@ -0,0 +1,128 @@
+#include <iostream>
+#include "cvconfig.h"
+
+#ifndef HAVE_OPENGL
+int main()
+{
+    std::cerr << "Library was built without OpenGL support" << std::endl;
+    return -1;
+}
+#else
+
+#ifdef WIN32
+    #define WIN32_LEAN_AND_MEAN 1
+    #define NOMINMAX 1
+    #include <windows.h>
+#endif
+
+#if defined(__APPLE__)
+    #include <OpenGL/gl.h>
+    #include <OpenGL/glu.h>
+#else
+    #include <GL/gl.h>
+    #include <GL/glu.h>
+#endif
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/opengl_interop.hpp"
+#include "opencv2/core/gpumat.hpp"
+#include "opencv2/highgui/highgui.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+const int win_width = 800;
+const int win_height = 640;
+
+struct DrawData
+{
+    GlArrays arr;
+    GlTexture2D tex;
+    GlBuffer indices;
+};
+
+void CV_CDECL draw(void* userdata);
+
+void CV_CDECL draw(void* userdata)
+{
+    static double angle = 0.0;
+
+    DrawData* data = static_cast<DrawData*>(userdata);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+    gluLookAt(0, 0, 4, 0, 0, 0, 0, 1, 0);
+    glRotated(angle, 0, 1, 0);
+
+    glEnable(GL_TEXTURE_2D);
+    data->tex.bind();
+
+    glDisable(GL_CULL_FACE);
+    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
+
+    render(data->arr, data->indices, RenderMode::TRIANGLES);
+
+    angle += 0.3;
+}
+
+int main(int argc, char* argv[])
+{
+    if (argc < 2)
+    {
+        cout << "Usage: " << argv[0] << " image" << endl;
+        return -1;
+    }
+
+    Mat img = imread(argv[1]);
+    if (img.empty())
+    {
+        cerr << "Can't open image " << argv[1] << endl;
+        return -1;
+    }
+
+    namedWindow("OpenGL", WINDOW_OPENGL);
+    resizeWindow("OpenGL", win_width, win_height);
+
+    Mat_<Vec2f> vertex(1, 4);
+    vertex << Vec2f(-1, 1), Vec2f(-1, -1), Vec2f(1, -1), Vec2f(1, 1);
+
+    Mat_<Vec2f> texCoords(1, 4);
+    texCoords << Vec2f(0, 0), Vec2f(0, 1), Vec2f(1, 1), Vec2f(1, 0);
+
+    Mat_<int> indices(1, 6);
+    indices << 0, 1, 2, 2, 3, 0;
+
+    DrawData data;
+
+    data.arr.setVertexArray(vertex);
+    data.arr.setTexCoordArray(texCoords);
+    data.arr.setAutoRelease(false);
+
+    data.indices.copyFrom(indices);
+    data.indices.setAutoRelease(false);
+
+    data.tex.copyFrom(img);
+    data.tex.setAutoRelease(false);
+
+    setOpenGlDrawCallback("OpenGL", draw, &data);
+
+    for (;;)
+    {
+        updateWindow("OpenGL");
+        int key = waitKey(10);
+        if ((key & 0xff) == 27)
+            break;
+    }
+
+    setOpenGlDrawCallback("OpenGL", 0, 0);
+    destroyAllWindows();
+
+    return 0;
+}
+
+#endif
diff --git a/samples/gpu/pyrlk_optical_flow.cpp b/samples/gpu/pyrlk_optical_flow.cpp
index 8792b9495..c2e765da1 100644
--- a/samples/gpu/pyrlk_optical_flow.cpp
+++ b/samples/gpu/pyrlk_optical_flow.cpp
@@ -3,7 +3,6 @@
 
 #include "cvconfig.h"
 #include "opencv2/core/core.hpp"
-#include "opencv2/core/opengl_interop.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/video/video.hpp"
@@ -66,40 +65,6 @@ static void drawArrows(Mat& frame, const vector<Point2f>& prevPts, const vector<
     }
 }
 
-#ifdef HAVE_OPENGL
-
-struct DrawData
-{
-    GlTexture tex;
-    GlArrays arr;
-};
-
-static void drawCallback(void* userdata)
-{
-    DrawData* data = static_cast<DrawData*>(userdata);
-
-    if (data->tex.empty() || data->arr.empty())
-        return;
-
-    static GlCamera camera;
-    static bool init_camera = true;
-
-    if (init_camera)
-    {
-        camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0);
-        camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0));
-        init_camera = false;
-    }
-
-    camera.setupProjectionMatrix();
-    camera.setupModelViewMatrix();
-
-    render(data->tex);
-    render(data->arr, RenderMode::TRIANGLES);
-}
-
-#endif
-
 template <typename T> inline T clamp (T x, T a, T b)
 {
     return ((x) > (a) ? ((x) < (b) ? (x) : (b)) : (a));
@@ -199,12 +164,6 @@ int main(int argc, const char* argv[])
     namedWindow("PyrLK [Sparse]", WINDOW_NORMAL);
     namedWindow("PyrLK [Dense] Flow Field", WINDOW_NORMAL);
 
-    #ifdef HAVE_OPENGL
-        namedWindow("PyrLK [Dense]", WINDOW_OPENGL);
-
-        setGlDevice();
-    #endif
-
     cout << "Image size : " << frame0.cols << " x " << frame0.rows << endl;
     cout << "Points count : " << points << endl;
 
@@ -270,21 +229,6 @@ int main(int argc, const char* argv[])
 
     imshow("PyrLK [Dense] Flow Field", flowField);
 
-    #ifdef HAVE_OPENGL
-        setOpenGlContext("PyrLK [Dense]");
-
-        GpuMat d_vertex, d_colors;
-        createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-
-        DrawData drawData;
-
-        drawData.tex.copyFrom(d_frame0Gray);
-        drawData.arr.setVertexArray(d_vertex);
-        drawData.arr.setColorArray(d_colors, false);
-
-        setOpenGlDrawCallback("PyrLK [Dense]", drawCallback, &drawData);
-    #endif
-
     waitKey();
 
     return 0;
diff --git a/samples/gpu/stereo_multi.cpp b/samples/gpu/stereo_multi.cpp
index c7fa5539b..d424bf90b 100644
--- a/samples/gpu/stereo_multi.cpp
+++ b/samples/gpu/stereo_multi.cpp
@@ -47,7 +47,7 @@ GpuMat d_result[2];
 // CPU result
 Mat result;
 
-void printHelp()
+static void printHelp()
 {
     std::cout << "Usage: stereo_multi_gpu --left <image> --right <image>\n";
 }

From 05d842bcd81ac5bb213ee34821c7df232dff55da Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 3 Dec 2012 13:11:06 +0400
Subject: [PATCH 111/155] a bit more opengl refactoring:

* added Access parameter to GlBuffer::mapHost
* added autoRelease parameter to all create methods
* fixed indentation in gl_core_3_1
* minor improvments for opengl sample
---
 .../include/opencv2/core/opengl_interop.hpp   |   33 +-
 modules/core/src/gl_core_3_1.cpp              | 5371 ++++++++---------
 modules/core/src/gl_core_3_1.hpp              | 2429 ++++----
 modules/core/src/opengl_interop.cpp           |   74 +-
 modules/gpu/test/test_opengl.cpp              |   25 +-
 samples/gpu/opengl.cpp                        |   13 +-
 6 files changed, 3945 insertions(+), 4000 deletions(-)

diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp
index 91fba7b7f..cda1a8b5d 100644
--- a/modules/core/include/opencv2/core/opengl_interop.hpp
+++ b/modules/core/include/opencv2/core/opengl_interop.hpp
@@ -71,6 +71,13 @@ public:
         PIXEL_UNPACK_BUFFER  = 0x88EC  //!< The buffer will be used for writing to OpenGL textures
     };
 
+    enum Access
+    {
+        READ_ONLY  = 0x88B8,
+        WRITE_ONLY = 0x88B9,
+        READ_WRITE = 0x88BA
+    };
+
     //! create empty buffer
     GlBuffer();
 
@@ -79,15 +86,15 @@ public:
     GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false);
 
     //! create buffer
-    GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER);
-    GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER);
+    GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
+    GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
     //! copy from host/device memory
-    explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER);
+    explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
     //! create buffer
-    void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER);
-    void create(Size asize, int atype, Target target = ARRAY_BUFFER) { create(asize.height, asize.width, atype, target); }
+    void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false);
+    void create(Size asize, int atype, Target target = ARRAY_BUFFER, bool autoRelease = false) { create(asize.height, asize.width, atype, target, autoRelease); }
 
     //! release memory and delete buffer object
     void release();
@@ -96,7 +103,7 @@ public:
     void setAutoRelease(bool flag);
 
     //! copy from host/device memory
-    void copyFrom(InputArray arr, Target target = ARRAY_BUFFER);
+    void copyFrom(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
     //! copy to host/device memory
     void copyTo(OutputArray arr, Target target = ARRAY_BUFFER) const;
@@ -111,7 +118,7 @@ public:
     static void unbind(Target target);
 
     //! map to host memory
-    Mat mapHost();
+    Mat mapHost(Access access);
     void unmapHost();
 
     //! map to device memory
@@ -162,15 +169,15 @@ public:
     GlTexture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false);
 
     //! create texture
-    GlTexture2D(int arows, int acols, Format aformat);
-    GlTexture2D(Size asize, Format aformat);
+    GlTexture2D(int arows, int acols, Format aformat, bool autoRelease = false);
+    GlTexture2D(Size asize, Format aformat, bool autoRelease = false);
 
     //! copy from host/device memory
-    explicit GlTexture2D(InputArray arr);
+    explicit GlTexture2D(InputArray arr, bool autoRelease = false);
 
     //! create texture
-    void create(int arows, int acols, Format aformat);
-    void create(Size asize, Format aformat) { create(asize.height, asize.width, aformat); }
+    void create(int arows, int acols, Format aformat, bool autoRelease = false);
+    void create(Size asize, Format aformat, bool autoRelease = false) { create(asize.height, asize.width, aformat, autoRelease); }
 
     //! release memory and delete texture object
     void release();
@@ -179,7 +186,7 @@ public:
     void setAutoRelease(bool flag);
 
     //! copy from host/device memory
-    void copyFrom(InputArray arr);
+    void copyFrom(InputArray arr, bool autoRelease = false);
 
     //! copy to host/device memory
     void copyTo(OutputArray arr, int ddepth = CV_32F) const;
diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp
index 9e4865efb..97c11d2e7 100644
--- a/modules/core/src/gl_core_3_1.cpp
+++ b/modules/core/src/gl_core_3_1.cpp
@@ -2,88 +2,81 @@
 
 #ifdef HAVE_OPENGL
 
-#include <algorithm>
-#include <string.h>
+#include <string>
 #include "gl_core_3_1.hpp"
 
 #if defined(__APPLE__)
-#include <mach-o/dyld.h>
+    #include <mach-o/dyld.h>
 
-static void* AppleGLGetProcAddress (const GLubyte *name)
-{
-  static const struct mach_header* image = NULL;
-  NSSymbol symbol;
-  char* symbolName;
-  if (NULL == image)
-  {
-    image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
-  }
-  /* prepend a '_' for the Unix C symbol mangling convention */
-  symbolName = malloc(strlen((const char*)name) + 2);
-  strcpy(symbolName+1, (const char*)name);
-  symbolName[0] = '_';
-  symbol = NULL;
-  /* if (NSIsSymbolNameDefined(symbolName))
-     symbol = NSLookupAndBindSymbol(symbolName); */
-  symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL;
-  free(symbolName);
-  return symbol ? NSAddressOfSymbol(symbol) : NULL;
-}
-#endif /* __APPLE__ */
+    static void* AppleGLGetProcAddress (const GLubyte *name)
+    {
+        static const struct mach_header* image = 0;
+        if (!image)
+            image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
+
+        // prepend a '_' for the Unix C symbol mangling convention
+        std::string symbolName = "_";
+        symbolName += std::string((const char*)name);
+
+        NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0;
+
+        return symbol ? NSAddressOfSymbol(symbol) : 0;
+    }
+#endif // __APPLE__
 
 #if defined(__sgi) || defined (__sun)
-#include <dlfcn.h>
-#include <stdio.h>
+    #include <dlfcn.h>
+    #include <stdio.h>
 
-static void* SunGetProcAddress (const GLubyte* name)
-{
-  static void* h = NULL;
-  static void* gpa;
+    static void* SunGetProcAddress (const GLubyte* name)
+    {
+        typedef void* (func_t*)(const GLubyte*);
 
-  if (h == NULL)
-  {
-    if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL;
-    gpa = dlsym(h, "glXGetProcAddress");
-  }
+        static void* h = 0;
+        static func_t gpa = 0;
 
-  if (gpa != NULL)
-    return ((void*(*)(const GLubyte*))gpa)(name);
-  else
-    return dlsym(h, (const char*)name);
-}
+        if (!h)
+        {
+            h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL);
+            if (!h)
+                return 0;
+            gpa = (func_t) dlsym(h, "glXGetProcAddress");
+        }
+
+        return gpa ? gpa(name) : dlsym(h, (const char*) name);
+    }
 #endif /* __sgi || __sun */
 
 #if defined(_WIN32)
+    #ifdef _MSC_VER
+        #pragma warning(disable: 4055)
+        #pragma warning(disable: 4054)
+    #endif
 
-#ifdef _MSC_VER
-#pragma warning(disable: 4055)
-#pragma warning(disable: 4054)
-#endif
-
-static int TestPointer(const PROC pTest)
-{
-    ptrdiff_t iTest;
-    if(!pTest) return 0;
-    iTest = (ptrdiff_t)pTest;
-
-    if(iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) return 0;
-
-    return 1;
-}
-
-static PROC WinGetProcAddress(const char *name)
-{
-    HMODULE glMod = NULL;
-    PROC pFunc = wglGetProcAddress((LPCSTR)name);
-    if(TestPointer(pFunc))
+    static int TestPointer(const PROC pTest)
     {
-        return pFunc;
-    }
-    glMod = GetModuleHandleA("OpenGL32.dll");
-    return (PROC)GetProcAddress(glMod, (LPCSTR)name);
-}
+        if(!pTest)
+            return 0;
 
-#define IntGetProcAddress(name) WinGetProcAddress(name)
+        ptrdiff_t iTest = (ptrdiff_t) pTest;
+
+        if (iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1)
+            return 0;
+
+        return 1;
+    }
+
+    static PROC WinGetProcAddress(const char* name)
+    {
+        PROC pFunc = wglGetProcAddress((LPCSTR) name);
+        if (TestPointer(pFunc))
+            return pFunc;
+
+        HMODULE glMod = GetModuleHandleA("OpenGL32.dll");
+        return (PROC) GetProcAddress(glMod, (LPCSTR) name);
+    }
+
+    #define IntGetProcAddress(name) WinGetProcAddress(name)
 #else
     #if defined(__APPLE__)
         #define IntGetProcAddress(name) AppleGLGetProcAddress(name)
@@ -93,2688 +86,2618 @@ static PROC WinGetProcAddress(const char *name)
         #else /* GLX */
             #include <GL/glx.h>
 
-            #define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name)
+            #define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*) name)
         #endif
     #endif
 #endif
 
 namespace gl
 {
-  namespace exts
-  {
-  }
-
-  // Extension: 1.1
-  typedef void (CODEGEN_FUNCPTR *PFNCULLFACEPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNFRONTFACEPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNHINTPROC)(GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNLINEWIDTHPROC)(GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNPOINTSIZEPROC)(GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNPOLYGONMODEPROC)(GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNSCISSORPROC)(GLint , GLint , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIPROC)(GLenum , GLenum , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARPROC)(GLbitfield );
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARSTENCILPROC)(GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARDEPTHPROC)(GLdouble );
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean );
-  typedef void (CODEGEN_FUNCPTR *PFNDEPTHMASKPROC)(GLboolean );
-  typedef void (CODEGEN_FUNCPTR *PFNDISABLEPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNENABLEPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNFINISHPROC)();
-  typedef void (CODEGEN_FUNCPTR *PFNFLUSHPROC)();
-  typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCPROC)(GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNLOGICOPPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCPROC)(GLenum , GLint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPPROC)(GLenum , GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNDEPTHFUNCPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREFPROC)(GLenum , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREIPROC)(GLenum , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNREADBUFFERPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANVPROC)(GLenum , GLboolean *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETDOUBLEVPROC)(GLenum , GLdouble *);
-  typedef GLenum (CODEGEN_FUNCPTR *PFNGETERRORPROC)();
-  typedef void (CODEGEN_FUNCPTR *PFNGETFLOATVPROC)(GLenum , GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERVPROC)(GLenum , GLint *);
-  typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNDEPTHRANGEPROC)(GLdouble , GLdouble );
-  typedef void (CODEGEN_FUNCPTR *PFNVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSPROC)(GLenum , GLint , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETPOINTERVPROC)(GLenum , GLvoid* *);
-  typedef void (CODEGEN_FUNCPTR *PFNPOLYGONOFFSETPROC)(GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNBINDTEXTUREPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETETEXTURESPROC)(GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENTEXTURESPROC)(GLsizei , GLuint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISTEXTUREPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNINDEXUBPROC)(GLubyte );
-  typedef void (CODEGEN_FUNCPTR *PFNINDEXUBVPROC)(const GLubyte *);
-
-  // Extension: 1.2
-  typedef void (CODEGEN_FUNCPTR *PFNBLENDCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWRANGEELEMENTSPROC)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
-
-  // Extension: 1.3
-  typedef void (CODEGEN_FUNCPTR *PFNACTIVETEXTUREPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNSAMPLECOVERAGEPROC)(GLfloat , GLboolean );
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE3DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETCOMPRESSEDTEXIMAGEPROC)(GLenum , GLint , GLvoid *);
-
-  // Extension: 1.4
-  typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWARRAYSPROC)(GLenum , const GLint *, const GLsizei *, GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWELEMENTSPROC)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFPROC)(GLenum , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFVPROC)(GLenum , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIPROC)(GLenum , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIVPROC)(GLenum , const GLint *);
-
-  // Extension: 1.5
-  typedef void (CODEGEN_FUNCPTR *PFNGENQUERIESPROC)(GLsizei , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNDELETEQUERIESPROC)(GLsizei , const GLuint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISQUERYPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBEGINQUERYPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNENDQUERYPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYIVPROC)(GLenum , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTIVPROC)(GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTUIVPROC)(GLuint , GLenum , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETEBUFFERSPROC)(GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENBUFFERSPROC)(GLsizei , GLuint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISBUFFERPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBUFFERDATAPROC)(GLenum , GLsizeiptr , const GLvoid *, GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , GLvoid *);
-  typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERPROC)(GLenum , GLenum );
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNUNMAPBUFFERPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPOINTERVPROC)(GLenum , GLenum , GLvoid* *);
-
-  // Extension: 2.0
-  typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONSEPARATEPROC)(GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERSPROC)(GLsizei , const GLenum *);
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCSEPARATEPROC)(GLenum , GLenum , GLint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKSEPARATEPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNATTACHSHADERPROC)(GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBINDATTRIBLOCATIONPROC)(GLuint , GLuint , const GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNCOMPILESHADERPROC)(GLuint );
-  typedef GLuint (CODEGEN_FUNCPTR *PFNCREATEPROGRAMPROC)();
-  typedef GLuint (CODEGEN_FUNCPTR *PFNCREATESHADERPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETEPROGRAMPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETESHADERPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDETACHSHADERPROC)(GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDISABLEVERTEXATTRIBARRAYPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNENABLEVERTEXATTRIBARRAYPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEATTRIBPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETATTACHEDSHADERSPROC)(GLuint , GLsizei , GLsizei *, GLuint *);
-  typedef GLint (CODEGEN_FUNCPTR *PFNGETATTRIBLOCATIONPROC)(GLuint , const GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMIVPROC)(GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERIVPROC)(GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETSHADERSOURCEPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
-  typedef GLint (CODEGEN_FUNCPTR *PFNGETUNIFORMLOCATIONPROC)(GLuint , const GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMFVPROC)(GLuint , GLint , GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMIVPROC)(GLuint , GLint , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBDVPROC)(GLuint , GLenum , GLdouble *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBFVPROC)(GLuint , GLenum , GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIVPROC)(GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBPOINTERVPROC)(GLuint , GLenum , GLvoid* *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISPROGRAMPROC)(GLuint );
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISSHADERPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNLINKPROGRAMPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNSHADERSOURCEPROC)(GLuint , GLsizei , const GLchar* const *, const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUSEPROGRAMPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FPROC)(GLint , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FPROC)(GLint , GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FPROC)(GLint , GLfloat , GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FPROC)(GLint , GLfloat , GLfloat , GLfloat , GLfloat );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IPROC)(GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IPROC)(GLint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IPROC)(GLint , GLint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IPROC)(GLint , GLint , GLint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FVPROC)(GLint , GLsizei , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FVPROC)(GLint , GLsizei , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FVPROC)(GLint , GLsizei , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FVPROC)(GLint , GLsizei , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IVPROC)(GLint , GLsizei , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IVPROC)(GLint , GLsizei , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IVPROC)(GLint , GLsizei , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IVPROC)(GLint , GLsizei , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNVALIDATEPROGRAMPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBPOINTERPROC)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *);
-
-  // Extension: 2.1
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
-
-  // Extension: ARB_vertex_array_object
-  typedef void (CODEGEN_FUNCPTR *PFNBINDVERTEXARRAYPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETEVERTEXARRAYSPROC)(GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENVERTEXARRAYSPROC)(GLsizei , GLuint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISVERTEXARRAYPROC)(GLuint );
-
-  // Extension: ARB_map_buffer_range
-  typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr , GLbitfield );
-  typedef void (CODEGEN_FUNCPTR *PFNFLUSHMAPPEDBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr );
-
-  // Extension: ARB_framebuffer_object
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISRENDERBUFFERPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBINDRENDERBUFFERPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETERENDERBUFFERSPROC)(GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENRENDERBUFFERSPROC)(GLsizei , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEPROC)(GLenum , GLenum , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNGETRENDERBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISFRAMEBUFFERPROC)(GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBINDFRAMEBUFFERPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDELETEFRAMEBUFFERSPROC)(GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENFRAMEBUFFERSPROC)(GLsizei , GLuint *);
-  typedef GLenum (CODEGEN_FUNCPTR *PFNCHECKFRAMEBUFFERSTATUSPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE1DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE2DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE3DPROC)(GLenum , GLenum , GLenum , GLuint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERRENDERBUFFERPROC)(GLenum , GLenum , GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum , GLenum , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGENERATEMIPMAPPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNBLITFRAMEBUFFERPROC)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum , GLsizei , GLenum , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURELAYERPROC)(GLenum , GLenum , GLuint , GLint , GLint );
-
-  // Extension: 3.0
-  typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKIPROC)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean );
-  typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANI_VPROC)(GLenum , GLuint , GLboolean *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERI_VPROC)(GLenum , GLuint , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNENABLEIPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNDISABLEIPROC)(GLenum , GLuint );
-  typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDIPROC)(GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNBEGINTRANSFORMFEEDBACKPROC)(GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNENDTRANSFORMFEEDBACKPROC)();
-  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERRANGEPROC)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr );
-  typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERBASEPROC)(GLenum , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNTRANSFORMFEEDBACKVARYINGSPROC)(GLuint , GLsizei , const GLchar* const *, GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNCLAMPCOLORPROC)(GLenum , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNBEGINCONDITIONALRENDERPROC)(GLuint , GLenum );
-  typedef void (CODEGEN_FUNCPTR *PFNENDCONDITIONALRENDERPROC)();
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBIPOINTERPROC)(GLuint , GLint , GLenum , GLsizei , const GLvoid *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIIVPROC)(GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIUIVPROC)(GLuint , GLenum , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IPROC)(GLuint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IPROC)(GLuint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IPROC)(GLuint , GLint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IPROC)(GLuint , GLint , GLint , GLint , GLint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIPROC)(GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIPROC)(GLuint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIPROC)(GLuint , GLuint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIPROC)(GLuint , GLuint , GLuint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IVPROC)(GLuint , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IVPROC)(GLuint , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IVPROC)(GLuint , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IVPROC)(GLuint , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIVPROC)(GLuint , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIVPROC)(GLuint , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIVPROC)(GLuint , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIVPROC)(GLuint , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4BVPROC)(GLuint , const GLbyte *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4SVPROC)(GLuint , const GLshort *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UBVPROC)(GLuint , const GLubyte *);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4USVPROC)(GLuint , const GLushort *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMUIVPROC)(GLuint , GLint , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNBINDFRAGDATALOCATIONPROC)(GLuint , GLuint , const GLchar *);
-  typedef GLint (CODEGEN_FUNCPTR *PFNGETFRAGDATALOCATIONPROC)(GLuint , const GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIPROC)(GLint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIPROC)(GLint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIPROC)(GLint , GLuint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIPROC)(GLint , GLuint , GLuint , GLuint , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIVPROC)(GLint , GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIVPROC)(GLint , GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIVPROC)(GLint , GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIVPROC)(GLint , GLsizei , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIIVPROC)(GLenum , GLenum , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIUIVPROC)(GLenum , GLenum , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIIVPROC)(GLenum , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIUIVPROC)(GLenum , GLenum , GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERIVPROC)(GLenum , GLint , const GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERUIVPROC)(GLenum , GLint , const GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFVPROC)(GLenum , GLint , const GLfloat *);
-  typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFIPROC)(GLenum , GLint , GLfloat , GLint );
-  typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGIPROC)(GLenum , GLuint );
-
-  // Extension: ARB_uniform_buffer_object
-  typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMINDICESPROC)(GLuint , GLsizei , const GLchar* const *, GLuint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMSIVPROC)(GLuint , GLsizei , const GLuint *, GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
-  typedef GLuint (CODEGEN_FUNCPTR *PFNGETUNIFORMBLOCKINDEXPROC)(GLuint , const GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKIVPROC)(GLuint , GLuint , GLenum , GLint *);
-  typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
-  typedef void (CODEGEN_FUNCPTR *PFNUNIFORMBLOCKBINDINGPROC)(GLuint , GLuint , GLuint );
-
-  // Extension: ARB_copy_buffer
-  typedef void (CODEGEN_FUNCPTR *PFNCOPYBUFFERSUBDATAPROC)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr );
-
-  // Extension: 3.1
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSINSTANCEDPROC)(GLenum , GLint , GLsizei , GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSINSTANCEDPROC)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei );
-  typedef void (CODEGEN_FUNCPTR *PFNTEXBUFFERPROC)(GLenum , GLenum , GLuint );
-  typedef void (CODEGEN_FUNCPTR *PFNPRIMITIVERESTARTINDEXPROC)(GLuint );
-
-  // Legacy
-  typedef void (CODEGEN_FUNCPTR *PFNENABLECLIENTSTATEPROC)(GLenum cap);
-  typedef void (CODEGEN_FUNCPTR *PFNDISABLECLIENTSTATEPROC)(GLenum cap);
-  typedef void (CODEGEN_FUNCPTR *PFNVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-  typedef void (CODEGEN_FUNCPTR *PFNNORMALPOINTERPROC)(GLenum type, GLsizei stride, const GLvoid *ptr);
-  typedef void (CODEGEN_FUNCPTR *PFNCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-  typedef void (CODEGEN_FUNCPTR *PFNTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-
-  typedef void (CODEGEN_FUNCPTR *PFNTEXENVIPROC)(GLenum target, GLenum pname, GLint param);
-
-  typedef void (CODEGEN_FUNCPTR *PFNMATRIXMODEPROC)(GLenum modem);
-  typedef void (CODEGEN_FUNCPTR *PFNLOADIDENTITYPROC)(void);
-  typedef void (CODEGEN_FUNCPTR *PFNORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
-
-  typedef void (CODEGEN_FUNCPTR *PFNCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue);
-
-
-
-  // Extension: 1.1
-  PFNCULLFACEPROC CullFace;
-  PFNFRONTFACEPROC FrontFace;
-  PFNHINTPROC Hint;
-  PFNLINEWIDTHPROC LineWidth;
-  PFNPOINTSIZEPROC PointSize;
-  PFNPOLYGONMODEPROC PolygonMode;
-  PFNSCISSORPROC Scissor;
-  PFNTEXPARAMETERFPROC TexParameterf;
-  PFNTEXPARAMETERFVPROC TexParameterfv;
-  PFNTEXPARAMETERIPROC TexParameteri;
-  PFNTEXPARAMETERIVPROC TexParameteriv;
-  PFNTEXIMAGE1DPROC TexImage1D;
-  PFNTEXIMAGE2DPROC TexImage2D;
-  PFNDRAWBUFFERPROC DrawBuffer;
-  PFNCLEARPROC Clear;
-  PFNCLEARCOLORPROC ClearColor;
-  PFNCLEARSTENCILPROC ClearStencil;
-  PFNCLEARDEPTHPROC ClearDepth;
-  PFNSTENCILMASKPROC StencilMask;
-  PFNCOLORMASKPROC ColorMask;
-  PFNDEPTHMASKPROC DepthMask;
-  PFNDISABLEPROC Disable;
-  PFNENABLEPROC Enable;
-  PFNFINISHPROC Finish;
-  PFNFLUSHPROC Flush;
-  PFNBLENDFUNCPROC BlendFunc;
-  PFNLOGICOPPROC LogicOp;
-  PFNSTENCILFUNCPROC StencilFunc;
-  PFNSTENCILOPPROC StencilOp;
-  PFNDEPTHFUNCPROC DepthFunc;
-  PFNPIXELSTOREFPROC PixelStoref;
-  PFNPIXELSTOREIPROC PixelStorei;
-  PFNREADBUFFERPROC ReadBuffer;
-  PFNREADPIXELSPROC ReadPixels;
-  PFNGETBOOLEANVPROC GetBooleanv;
-  PFNGETDOUBLEVPROC GetDoublev;
-  PFNGETERRORPROC GetError;
-  PFNGETFLOATVPROC GetFloatv;
-  PFNGETINTEGERVPROC GetIntegerv;
-  PFNGETSTRINGPROC GetString;
-  PFNGETTEXIMAGEPROC GetTexImage;
-  PFNGETTEXPARAMETERFVPROC GetTexParameterfv;
-  PFNGETTEXPARAMETERIVPROC GetTexParameteriv;
-  PFNGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv;
-  PFNGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv;
-  PFNISENABLEDPROC IsEnabled;
-  PFNDEPTHRANGEPROC DepthRange;
-  PFNVIEWPORTPROC Viewport;
-  PFNDRAWARRAYSPROC DrawArrays;
-  PFNDRAWELEMENTSPROC DrawElements;
-  PFNGETPOINTERVPROC GetPointerv;
-  PFNPOLYGONOFFSETPROC PolygonOffset;
-  PFNCOPYTEXIMAGE1DPROC CopyTexImage1D;
-  PFNCOPYTEXIMAGE2DPROC CopyTexImage2D;
-  PFNCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D;
-  PFNCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
-  PFNTEXSUBIMAGE1DPROC TexSubImage1D;
-  PFNTEXSUBIMAGE2DPROC TexSubImage2D;
-  PFNBINDTEXTUREPROC BindTexture;
-  PFNDELETETEXTURESPROC DeleteTextures;
-  PFNGENTEXTURESPROC GenTextures;
-  PFNISTEXTUREPROC IsTexture;
-  PFNINDEXUBPROC Indexub;
-  PFNINDEXUBVPROC Indexubv;
-
-  // Extension: 1.2
-  PFNBLENDCOLORPROC BlendColor;
-  PFNBLENDEQUATIONPROC BlendEquation;
-  PFNDRAWRANGEELEMENTSPROC DrawRangeElements;
-  PFNTEXSUBIMAGE3DPROC TexSubImage3D;
-  PFNCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D;
-
-  // Extension: 1.3
-  PFNACTIVETEXTUREPROC ActiveTexture;
-  PFNSAMPLECOVERAGEPROC SampleCoverage;
-  PFNCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D;
-  PFNCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
-  PFNCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D;
-  PFNCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D;
-  PFNCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
-  PFNCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D;
-  PFNGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage;
-
-  // Extension: 1.4
-  PFNBLENDFUNCSEPARATEPROC BlendFuncSeparate;
-  PFNMULTIDRAWARRAYSPROC MultiDrawArrays;
-  PFNMULTIDRAWELEMENTSPROC MultiDrawElements;
-  PFNPOINTPARAMETERFPROC PointParameterf;
-  PFNPOINTPARAMETERFVPROC PointParameterfv;
-  PFNPOINTPARAMETERIPROC PointParameteri;
-  PFNPOINTPARAMETERIVPROC PointParameteriv;
-
-  // Extension: 1.5
-  PFNGENQUERIESPROC GenQueries;
-  PFNDELETEQUERIESPROC DeleteQueries;
-  PFNISQUERYPROC IsQuery;
-  PFNBEGINQUERYPROC BeginQuery;
-  PFNENDQUERYPROC EndQuery;
-  PFNGETQUERYIVPROC GetQueryiv;
-  PFNGETQUERYOBJECTIVPROC GetQueryObjectiv;
-  PFNGETQUERYOBJECTUIVPROC GetQueryObjectuiv;
-  PFNBINDBUFFERPROC BindBuffer;
-  PFNDELETEBUFFERSPROC DeleteBuffers;
-  PFNGENBUFFERSPROC GenBuffers;
-  PFNISBUFFERPROC IsBuffer;
-  PFNBUFFERDATAPROC BufferData;
-  PFNBUFFERSUBDATAPROC BufferSubData;
-  PFNGETBUFFERSUBDATAPROC GetBufferSubData;
-  PFNMAPBUFFERPROC MapBuffer;
-  PFNUNMAPBUFFERPROC UnmapBuffer;
-  PFNGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
-  PFNGETBUFFERPOINTERVPROC GetBufferPointerv;
-
-  // Extension: 2.0
-  PFNBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
-  PFNDRAWBUFFERSPROC DrawBuffers;
-  PFNSTENCILOPSEPARATEPROC StencilOpSeparate;
-  PFNSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
-  PFNSTENCILMASKSEPARATEPROC StencilMaskSeparate;
-  PFNATTACHSHADERPROC AttachShader;
-  PFNBINDATTRIBLOCATIONPROC BindAttribLocation;
-  PFNCOMPILESHADERPROC CompileShader;
-  PFNCREATEPROGRAMPROC CreateProgram;
-  PFNCREATESHADERPROC CreateShader;
-  PFNDELETEPROGRAMPROC DeleteProgram;
-  PFNDELETESHADERPROC DeleteShader;
-  PFNDETACHSHADERPROC DetachShader;
-  PFNDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
-  PFNENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
-  PFNGETACTIVEATTRIBPROC GetActiveAttrib;
-  PFNGETACTIVEUNIFORMPROC GetActiveUniform;
-  PFNGETATTACHEDSHADERSPROC GetAttachedShaders;
-  PFNGETATTRIBLOCATIONPROC GetAttribLocation;
-  PFNGETPROGRAMIVPROC GetProgramiv;
-  PFNGETPROGRAMINFOLOGPROC GetProgramInfoLog;
-  PFNGETSHADERIVPROC GetShaderiv;
-  PFNGETSHADERINFOLOGPROC GetShaderInfoLog;
-  PFNGETSHADERSOURCEPROC GetShaderSource;
-  PFNGETUNIFORMLOCATIONPROC GetUniformLocation;
-  PFNGETUNIFORMFVPROC GetUniformfv;
-  PFNGETUNIFORMIVPROC GetUniformiv;
-  PFNGETVERTEXATTRIBDVPROC GetVertexAttribdv;
-  PFNGETVERTEXATTRIBFVPROC GetVertexAttribfv;
-  PFNGETVERTEXATTRIBIVPROC GetVertexAttribiv;
-  PFNGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
-  PFNISPROGRAMPROC IsProgram;
-  PFNISSHADERPROC IsShader;
-  PFNLINKPROGRAMPROC LinkProgram;
-  PFNSHADERSOURCEPROC ShaderSource;
-  PFNUSEPROGRAMPROC UseProgram;
-  PFNUNIFORM1FPROC Uniform1f;
-  PFNUNIFORM2FPROC Uniform2f;
-  PFNUNIFORM3FPROC Uniform3f;
-  PFNUNIFORM4FPROC Uniform4f;
-  PFNUNIFORM1IPROC Uniform1i;
-  PFNUNIFORM2IPROC Uniform2i;
-  PFNUNIFORM3IPROC Uniform3i;
-  PFNUNIFORM4IPROC Uniform4i;
-  PFNUNIFORM1FVPROC Uniform1fv;
-  PFNUNIFORM2FVPROC Uniform2fv;
-  PFNUNIFORM3FVPROC Uniform3fv;
-  PFNUNIFORM4FVPROC Uniform4fv;
-  PFNUNIFORM1IVPROC Uniform1iv;
-  PFNUNIFORM2IVPROC Uniform2iv;
-  PFNUNIFORM3IVPROC Uniform3iv;
-  PFNUNIFORM4IVPROC Uniform4iv;
-  PFNUNIFORMMATRIX2FVPROC UniformMatrix2fv;
-  PFNUNIFORMMATRIX3FVPROC UniformMatrix3fv;
-  PFNUNIFORMMATRIX4FVPROC UniformMatrix4fv;
-  PFNVALIDATEPROGRAMPROC ValidateProgram;
-  PFNVERTEXATTRIBPOINTERPROC VertexAttribPointer;
-
-  // Extension: 2.1
-  PFNUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv;
-  PFNUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv;
-  PFNUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv;
-  PFNUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv;
-  PFNUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv;
-  PFNUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv;
-
-  // Extension: ARB_vertex_array_object
-  PFNBINDVERTEXARRAYPROC BindVertexArray;
-  PFNDELETEVERTEXARRAYSPROC DeleteVertexArrays;
-  PFNGENVERTEXARRAYSPROC GenVertexArrays;
-  PFNISVERTEXARRAYPROC IsVertexArray;
-
-  // Extension: ARB_map_buffer_range
-  PFNMAPBUFFERRANGEPROC MapBufferRange;
-  PFNFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange;
-
-  // Extension: ARB_framebuffer_object
-  PFNISRENDERBUFFERPROC IsRenderbuffer;
-  PFNBINDRENDERBUFFERPROC BindRenderbuffer;
-  PFNDELETERENDERBUFFERSPROC DeleteRenderbuffers;
-  PFNGENRENDERBUFFERSPROC GenRenderbuffers;
-  PFNRENDERBUFFERSTORAGEPROC RenderbufferStorage;
-  PFNGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
-  PFNISFRAMEBUFFERPROC IsFramebuffer;
-  PFNBINDFRAMEBUFFERPROC BindFramebuffer;
-  PFNDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
-  PFNGENFRAMEBUFFERSPROC GenFramebuffers;
-  PFNCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
-  PFNFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D;
-  PFNFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
-  PFNFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D;
-  PFNFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
-  PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
-  PFNGENERATEMIPMAPPROC GenerateMipmap;
-  PFNBLITFRAMEBUFFERPROC BlitFramebuffer;
-  PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample;
-  PFNFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer;
-
-  // Extension: 3.0
-  PFNCOLORMASKIPROC ColorMaski;
-  PFNGETBOOLEANI_VPROC GetBooleani_v;
-  PFNGETINTEGERI_VPROC GetIntegeri_v;
-  PFNENABLEIPROC Enablei;
-  PFNDISABLEIPROC Disablei;
-  PFNISENABLEDIPROC IsEnabledi;
-  PFNBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback;
-  PFNENDTRANSFORMFEEDBACKPROC EndTransformFeedback;
-  PFNBINDBUFFERRANGEPROC BindBufferRange;
-  PFNBINDBUFFERBASEPROC BindBufferBase;
-  PFNTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings;
-  PFNGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying;
-  PFNCLAMPCOLORPROC ClampColor;
-  PFNBEGINCONDITIONALRENDERPROC BeginConditionalRender;
-  PFNENDCONDITIONALRENDERPROC EndConditionalRender;
-  PFNVERTEXATTRIBIPOINTERPROC VertexAttribIPointer;
-  PFNGETVERTEXATTRIBIIVPROC GetVertexAttribIiv;
-  PFNGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv;
-  PFNVERTEXATTRIBI1IPROC VertexAttribI1i;
-  PFNVERTEXATTRIBI2IPROC VertexAttribI2i;
-  PFNVERTEXATTRIBI3IPROC VertexAttribI3i;
-  PFNVERTEXATTRIBI4IPROC VertexAttribI4i;
-  PFNVERTEXATTRIBI1UIPROC VertexAttribI1ui;
-  PFNVERTEXATTRIBI2UIPROC VertexAttribI2ui;
-  PFNVERTEXATTRIBI3UIPROC VertexAttribI3ui;
-  PFNVERTEXATTRIBI4UIPROC VertexAttribI4ui;
-  PFNVERTEXATTRIBI1IVPROC VertexAttribI1iv;
-  PFNVERTEXATTRIBI2IVPROC VertexAttribI2iv;
-  PFNVERTEXATTRIBI3IVPROC VertexAttribI3iv;
-  PFNVERTEXATTRIBI4IVPROC VertexAttribI4iv;
-  PFNVERTEXATTRIBI1UIVPROC VertexAttribI1uiv;
-  PFNVERTEXATTRIBI2UIVPROC VertexAttribI2uiv;
-  PFNVERTEXATTRIBI3UIVPROC VertexAttribI3uiv;
-  PFNVERTEXATTRIBI4UIVPROC VertexAttribI4uiv;
-  PFNVERTEXATTRIBI4BVPROC VertexAttribI4bv;
-  PFNVERTEXATTRIBI4SVPROC VertexAttribI4sv;
-  PFNVERTEXATTRIBI4UBVPROC VertexAttribI4ubv;
-  PFNVERTEXATTRIBI4USVPROC VertexAttribI4usv;
-  PFNGETUNIFORMUIVPROC GetUniformuiv;
-  PFNBINDFRAGDATALOCATIONPROC BindFragDataLocation;
-  PFNGETFRAGDATALOCATIONPROC GetFragDataLocation;
-  PFNUNIFORM1UIPROC Uniform1ui;
-  PFNUNIFORM2UIPROC Uniform2ui;
-  PFNUNIFORM3UIPROC Uniform3ui;
-  PFNUNIFORM4UIPROC Uniform4ui;
-  PFNUNIFORM1UIVPROC Uniform1uiv;
-  PFNUNIFORM2UIVPROC Uniform2uiv;
-  PFNUNIFORM3UIVPROC Uniform3uiv;
-  PFNUNIFORM4UIVPROC Uniform4uiv;
-  PFNTEXPARAMETERIIVPROC TexParameterIiv;
-  PFNTEXPARAMETERIUIVPROC TexParameterIuiv;
-  PFNGETTEXPARAMETERIIVPROC GetTexParameterIiv;
-  PFNGETTEXPARAMETERIUIVPROC GetTexParameterIuiv;
-  PFNCLEARBUFFERIVPROC ClearBufferiv;
-  PFNCLEARBUFFERUIVPROC ClearBufferuiv;
-  PFNCLEARBUFFERFVPROC ClearBufferfv;
-  PFNCLEARBUFFERFIPROC ClearBufferfi;
-  PFNGETSTRINGIPROC GetStringi;
-
-  // Extension: ARB_uniform_buffer_object
-  PFNGETUNIFORMINDICESPROC GetUniformIndices;
-  PFNGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv;
-  PFNGETACTIVEUNIFORMNAMEPROC GetActiveUniformName;
-  PFNGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex;
-  PFNGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv;
-  PFNGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName;
-  PFNUNIFORMBLOCKBINDINGPROC UniformBlockBinding;
-
-  // Extension: ARB_copy_buffer
-  PFNCOPYBUFFERSUBDATAPROC CopyBufferSubData;
-
-  // Extension: 3.1
-  PFNDRAWARRAYSINSTANCEDPROC DrawArraysInstanced;
-  PFNDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced;
-  PFNTEXBUFFERPROC TexBuffer;
-  PFNPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex;
-
-  // Legacy
-  PFNENABLECLIENTSTATEPROC EnableClientState;
-  PFNDISABLECLIENTSTATEPROC DisableClientState;
-  PFNVERTEXPOINTERPROC VertexPointer;
-  PFNNORMALPOINTERPROC NormalPointer;
-  PFNCOLORPOINTERPROC ColorPointer;
-  PFNTEXCOORDPOINTERPROC TexCoordPointer;
-
-  PFNTEXENVIPROC TexEnvi;
-
-  PFNMATRIXMODEPROC MatrixMode;
-  PFNLOADIDENTITYPROC LoadIdentity;
-  PFNORTHOPROC Ortho;
-
-  PFNCOLOR3DPROC Color3d;
-
-
-  // Extension: 1.1
-  static void CODEGEN_FUNCPTR Switch_CullFace(GLenum mode)
-  {
-    CullFace = (PFNCULLFACEPROC)IntGetProcAddress("glCullFace");
-    CullFace(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FrontFace(GLenum mode)
-  {
-    FrontFace = (PFNFRONTFACEPROC)IntGetProcAddress("glFrontFace");
-    FrontFace(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Hint(GLenum target, GLenum mode)
-  {
-    Hint = (PFNHINTPROC)IntGetProcAddress("glHint");
-    Hint(target, mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_LineWidth(GLfloat width)
-  {
-    LineWidth = (PFNLINEWIDTHPROC)IntGetProcAddress("glLineWidth");
-    LineWidth(width);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PointSize(GLfloat size)
-  {
-    PointSize = (PFNPOINTSIZEPROC)IntGetProcAddress("glPointSize");
-    PointSize(size);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PolygonMode(GLenum face, GLenum mode)
-  {
-    PolygonMode = (PFNPOLYGONMODEPROC)IntGetProcAddress("glPolygonMode");
-    PolygonMode(face, mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
-  {
-    Scissor = (PFNSCISSORPROC)IntGetProcAddress("glScissor");
-    Scissor(x, y, width, height);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameterf(GLenum target, GLenum pname, GLfloat param)
-  {
-    TexParameterf = (PFNTEXPARAMETERFPROC)IntGetProcAddress("glTexParameterf");
-    TexParameterf(target, pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-  {
-    TexParameterfv = (PFNTEXPARAMETERFVPROC)IntGetProcAddress("glTexParameterfv");
-    TexParameterfv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameteri(GLenum target, GLenum pname, GLint param)
-  {
-    TexParameteri = (PFNTEXPARAMETERIPROC)IntGetProcAddress("glTexParameteri");
-    TexParameteri(target, pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
-  {
-    TexParameteriv = (PFNTEXPARAMETERIVPROC)IntGetProcAddress("glTexParameteriv");
-    TexParameteriv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-  {
-    TexImage1D = (PFNTEXIMAGE1DPROC)IntGetProcAddress("glTexImage1D");
-    TexImage1D(target, level, internalformat, width, border, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
-  {
-    TexImage2D = (PFNTEXIMAGE2DPROC)IntGetProcAddress("glTexImage2D");
-    TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawBuffer(GLenum mode)
-  {
-    DrawBuffer = (PFNDRAWBUFFERPROC)IntGetProcAddress("glDrawBuffer");
-    DrawBuffer(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Clear(GLbitfield mask)
-  {
-    Clear = (PFNCLEARPROC)IntGetProcAddress("glClear");
-    Clear(mask);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-  {
-    ClearColor = (PFNCLEARCOLORPROC)IntGetProcAddress("glClearColor");
-    ClearColor(red, green, blue, alpha);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearStencil(GLint s)
-  {
-    ClearStencil = (PFNCLEARSTENCILPROC)IntGetProcAddress("glClearStencil");
-    ClearStencil(s);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearDepth(GLdouble depth)
-  {
-    ClearDepth = (PFNCLEARDEPTHPROC)IntGetProcAddress("glClearDepth");
-    ClearDepth(depth);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilMask(GLuint mask)
-  {
-    StencilMask = (PFNSTENCILMASKPROC)IntGetProcAddress("glStencilMask");
-    StencilMask(mask);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-  {
-    ColorMask = (PFNCOLORMASKPROC)IntGetProcAddress("glColorMask");
-    ColorMask(red, green, blue, alpha);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DepthMask(GLboolean flag)
-  {
-    DepthMask = (PFNDEPTHMASKPROC)IntGetProcAddress("glDepthMask");
-    DepthMask(flag);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Disable(GLenum cap)
-  {
-    Disable = (PFNDISABLEPROC)IntGetProcAddress("glDisable");
-    Disable(cap);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Enable(GLenum cap)
-  {
-    Enable = (PFNENABLEPROC)IntGetProcAddress("glEnable");
-    Enable(cap);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Finish()
-  {
-    Finish = (PFNFINISHPROC)IntGetProcAddress("glFinish");
-    Finish();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Flush()
-  {
-    Flush = (PFNFLUSHPROC)IntGetProcAddress("glFlush");
-    Flush();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BlendFunc(GLenum sfactor, GLenum dfactor)
-  {
-    BlendFunc = (PFNBLENDFUNCPROC)IntGetProcAddress("glBlendFunc");
-    BlendFunc(sfactor, dfactor);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_LogicOp(GLenum opcode)
-  {
-    LogicOp = (PFNLOGICOPPROC)IntGetProcAddress("glLogicOp");
-    LogicOp(opcode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilFunc(GLenum func, GLint ref, GLuint mask)
-  {
-    StencilFunc = (PFNSTENCILFUNCPROC)IntGetProcAddress("glStencilFunc");
-    StencilFunc(func, ref, mask);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-  {
-    StencilOp = (PFNSTENCILOPPROC)IntGetProcAddress("glStencilOp");
-    StencilOp(fail, zfail, zpass);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DepthFunc(GLenum func)
-  {
-    DepthFunc = (PFNDEPTHFUNCPROC)IntGetProcAddress("glDepthFunc");
-    DepthFunc(func);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PixelStoref(GLenum pname, GLfloat param)
-  {
-    PixelStoref = (PFNPIXELSTOREFPROC)IntGetProcAddress("glPixelStoref");
-    PixelStoref(pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PixelStorei(GLenum pname, GLint param)
-  {
-    PixelStorei = (PFNPIXELSTOREIPROC)IntGetProcAddress("glPixelStorei");
-    PixelStorei(pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ReadBuffer(GLenum mode)
-  {
-    ReadBuffer = (PFNREADBUFFERPROC)IntGetProcAddress("glReadBuffer");
-    ReadBuffer(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
-  {
-    ReadPixels = (PFNREADPIXELSPROC)IntGetProcAddress("glReadPixels");
-    ReadPixels(x, y, width, height, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetBooleanv(GLenum pname, GLboolean *params)
-  {
-    GetBooleanv = (PFNGETBOOLEANVPROC)IntGetProcAddress("glGetBooleanv");
-    GetBooleanv(pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetDoublev(GLenum pname, GLdouble *params)
-  {
-    GetDoublev = (PFNGETDOUBLEVPROC)IntGetProcAddress("glGetDoublev");
-    GetDoublev(pname, params);
-  }
-
-  static GLenum CODEGEN_FUNCPTR Switch_GetError()
-  {
-    GetError = (PFNGETERRORPROC)IntGetProcAddress("glGetError");
-    return GetError();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetFloatv(GLenum pname, GLfloat *params)
-  {
-    GetFloatv = (PFNGETFLOATVPROC)IntGetProcAddress("glGetFloatv");
-    GetFloatv(pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetIntegerv(GLenum pname, GLint *params)
-  {
-    GetIntegerv = (PFNGETINTEGERVPROC)IntGetProcAddress("glGetIntegerv");
-    GetIntegerv(pname, params);
-  }
-
-  static const GLubyte * CODEGEN_FUNCPTR Switch_GetString(GLenum name)
-  {
-    GetString = (PFNGETSTRINGPROC)IntGetProcAddress("glGetString");
-    return GetString(name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-  {
-    GetTexImage = (PFNGETTEXIMAGEPROC)IntGetProcAddress("glGetTexImage");
-    GetTexImage(target, level, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-  {
-    GetTexParameterfv = (PFNGETTEXPARAMETERFVPROC)IntGetProcAddress("glGetTexParameterfv");
-    GetTexParameterfv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-  {
-    GetTexParameteriv = (PFNGETTEXPARAMETERIVPROC)IntGetProcAddress("glGetTexParameteriv");
-    GetTexParameteriv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-  {
-    GetTexLevelParameterfv = (PFNGETTEXLEVELPARAMETERFVPROC)IntGetProcAddress("glGetTexLevelParameterfv");
-    GetTexLevelParameterfv(target, level, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-  {
-    GetTexLevelParameteriv = (PFNGETTEXLEVELPARAMETERIVPROC)IntGetProcAddress("glGetTexLevelParameteriv");
-    GetTexLevelParameteriv(target, level, pname, params);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsEnabled(GLenum cap)
-  {
-    IsEnabled = (PFNISENABLEDPROC)IntGetProcAddress("glIsEnabled");
-    return IsEnabled(cap);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DepthRange(GLdouble ren_near, GLdouble ren_far)
-  {
-    DepthRange = (PFNDEPTHRANGEPROC)IntGetProcAddress("glDepthRange");
-    DepthRange(ren_near, ren_far);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
-  {
-    Viewport = (PFNVIEWPORTPROC)IntGetProcAddress("glViewport");
-    Viewport(x, y, width, height);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawArrays(GLenum mode, GLint first, GLsizei count)
-  {
-    DrawArrays = (PFNDRAWARRAYSPROC)IntGetProcAddress("glDrawArrays");
-    DrawArrays(mode, first, count);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
-  {
-    DrawElements = (PFNDRAWELEMENTSPROC)IntGetProcAddress("glDrawElements");
-    DrawElements(mode, count, type, indices);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetPointerv(GLenum pname, GLvoid* *params)
-  {
-    GetPointerv = (PFNGETPOINTERVPROC)IntGetProcAddress("glGetPointerv");
-    GetPointerv(pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PolygonOffset(GLfloat factor, GLfloat units)
-  {
-    PolygonOffset = (PFNPOLYGONOFFSETPROC)IntGetProcAddress("glPolygonOffset");
-    PolygonOffset(factor, units);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-  {
-    CopyTexImage1D = (PFNCOPYTEXIMAGE1DPROC)IntGetProcAddress("glCopyTexImage1D");
-    CopyTexImage1D(target, level, internalformat, x, y, width, border);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-  {
-    CopyTexImage2D = (PFNCOPYTEXIMAGE2DPROC)IntGetProcAddress("glCopyTexImage2D");
-    CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-  {
-    CopyTexSubImage1D = (PFNCOPYTEXSUBIMAGE1DPROC)IntGetProcAddress("glCopyTexSubImage1D");
-    CopyTexSubImage1D(target, level, xoffset, x, y, width);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-  {
-    CopyTexSubImage2D = (PFNCOPYTEXSUBIMAGE2DPROC)IntGetProcAddress("glCopyTexSubImage2D");
-    CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
-  {
-    TexSubImage1D = (PFNTEXSUBIMAGE1DPROC)IntGetProcAddress("glTexSubImage1D");
-    TexSubImage1D(target, level, xoffset, width, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-  {
-    TexSubImage2D = (PFNTEXSUBIMAGE2DPROC)IntGetProcAddress("glTexSubImage2D");
-    TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindTexture(GLenum target, GLuint texture)
-  {
-    BindTexture = (PFNBINDTEXTUREPROC)IntGetProcAddress("glBindTexture");
-    BindTexture(target, texture);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteTextures(GLsizei n, const GLuint *textures)
-  {
-    DeleteTextures = (PFNDELETETEXTURESPROC)IntGetProcAddress("glDeleteTextures");
-    DeleteTextures(n, textures);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenTextures(GLsizei n, GLuint *textures)
-  {
-    GenTextures = (PFNGENTEXTURESPROC)IntGetProcAddress("glGenTextures");
-    GenTextures(n, textures);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsTexture(GLuint texture)
-  {
-    IsTexture = (PFNISTEXTUREPROC)IntGetProcAddress("glIsTexture");
-    return IsTexture(texture);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Indexub(GLubyte c)
-  {
-    Indexub = (PFNINDEXUBPROC)IntGetProcAddress("glIndexub");
-    Indexub(c);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Indexubv(const GLubyte *c)
-  {
-    Indexubv = (PFNINDEXUBVPROC)IntGetProcAddress("glIndexubv");
-    Indexubv(c);
-  }
-
-
-  // Extension: 1.2
-  static void CODEGEN_FUNCPTR Switch_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
-  {
-    BlendColor = (PFNBLENDCOLORPROC)IntGetProcAddress("glBlendColor");
-    BlendColor(red, green, blue, alpha);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BlendEquation(GLenum mode)
-  {
-    BlendEquation = (PFNBLENDEQUATIONPROC)IntGetProcAddress("glBlendEquation");
-    BlendEquation(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
-  {
-    DrawRangeElements = (PFNDRAWRANGEELEMENTSPROC)IntGetProcAddress("glDrawRangeElements");
-    DrawRangeElements(mode, start, end, count, type, indices);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
-  {
-    TexSubImage3D = (PFNTEXSUBIMAGE3DPROC)IntGetProcAddress("glTexSubImage3D");
-    TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-  {
-    CopyTexSubImage3D = (PFNCOPYTEXSUBIMAGE3DPROC)IntGetProcAddress("glCopyTexSubImage3D");
-    CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-  }
-
-
-  // Extension: 1.3
-  static void CODEGEN_FUNCPTR Switch_ActiveTexture(GLenum texture)
-  {
-    ActiveTexture = (PFNACTIVETEXTUREPROC)IntGetProcAddress("glActiveTexture");
-    ActiveTexture(texture);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_SampleCoverage(GLfloat value, GLboolean invert)
-  {
-    SampleCoverage = (PFNSAMPLECOVERAGEPROC)IntGetProcAddress("glSampleCoverage");
-    SampleCoverage(value, invert);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexImage3D = (PFNCOMPRESSEDTEXIMAGE3DPROC)IntGetProcAddress("glCompressedTexImage3D");
-    CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexImage2D = (PFNCOMPRESSEDTEXIMAGE2DPROC)IntGetProcAddress("glCompressedTexImage2D");
-    CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexImage1D = (PFNCOMPRESSEDTEXIMAGE1DPROC)IntGetProcAddress("glCompressedTexImage1D");
-    CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexSubImage3D = (PFNCOMPRESSEDTEXSUBIMAGE3DPROC)IntGetProcAddress("glCompressedTexSubImage3D");
-    CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexSubImage2D = (PFNCOMPRESSEDTEXSUBIMAGE2DPROC)IntGetProcAddress("glCompressedTexSubImage2D");
-    CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
-  {
-    CompressedTexSubImage1D = (PFNCOMPRESSEDTEXSUBIMAGE1DPROC)IntGetProcAddress("glCompressedTexSubImage1D");
-    CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
-  {
-    GetCompressedTexImage = (PFNGETCOMPRESSEDTEXIMAGEPROC)IntGetProcAddress("glGetCompressedTexImage");
-    GetCompressedTexImage(target, level, img);
-  }
-
-
-  // Extension: 1.4
-  static void CODEGEN_FUNCPTR Switch_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-  {
-    BlendFuncSeparate = (PFNBLENDFUNCSEPARATEPROC)IntGetProcAddress("glBlendFuncSeparate");
-    BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_MultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
-  {
-    MultiDrawArrays = (PFNMULTIDRAWARRAYSPROC)IntGetProcAddress("glMultiDrawArrays");
-    MultiDrawArrays(mode, first, count, drawcount);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
-  {
-    MultiDrawElements = (PFNMULTIDRAWELEMENTSPROC)IntGetProcAddress("glMultiDrawElements");
-    MultiDrawElements(mode, count, type, indices, drawcount);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PointParameterf(GLenum pname, GLfloat param)
-  {
-    PointParameterf = (PFNPOINTPARAMETERFPROC)IntGetProcAddress("glPointParameterf");
-    PointParameterf(pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PointParameterfv(GLenum pname, const GLfloat *params)
-  {
-    PointParameterfv = (PFNPOINTPARAMETERFVPROC)IntGetProcAddress("glPointParameterfv");
-    PointParameterfv(pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PointParameteri(GLenum pname, GLint param)
-  {
-    PointParameteri = (PFNPOINTPARAMETERIPROC)IntGetProcAddress("glPointParameteri");
-    PointParameteri(pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PointParameteriv(GLenum pname, const GLint *params)
-  {
-    PointParameteriv = (PFNPOINTPARAMETERIVPROC)IntGetProcAddress("glPointParameteriv");
-    PointParameteriv(pname, params);
-  }
-
-
-  // Extension: 1.5
-  static void CODEGEN_FUNCPTR Switch_GenQueries(GLsizei n, GLuint *ids)
-  {
-    GenQueries = (PFNGENQUERIESPROC)IntGetProcAddress("glGenQueries");
-    GenQueries(n, ids);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteQueries(GLsizei n, const GLuint *ids)
-  {
-    DeleteQueries = (PFNDELETEQUERIESPROC)IntGetProcAddress("glDeleteQueries");
-    DeleteQueries(n, ids);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsQuery(GLuint id)
-  {
-    IsQuery = (PFNISQUERYPROC)IntGetProcAddress("glIsQuery");
-    return IsQuery(id);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BeginQuery(GLenum target, GLuint id)
-  {
-    BeginQuery = (PFNBEGINQUERYPROC)IntGetProcAddress("glBeginQuery");
-    BeginQuery(target, id);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_EndQuery(GLenum target)
-  {
-    EndQuery = (PFNENDQUERYPROC)IntGetProcAddress("glEndQuery");
-    EndQuery(target);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetQueryiv(GLenum target, GLenum pname, GLint *params)
-  {
-    GetQueryiv = (PFNGETQUERYIVPROC)IntGetProcAddress("glGetQueryiv");
-    GetQueryiv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
-  {
-    GetQueryObjectiv = (PFNGETQUERYOBJECTIVPROC)IntGetProcAddress("glGetQueryObjectiv");
-    GetQueryObjectiv(id, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
-  {
-    GetQueryObjectuiv = (PFNGETQUERYOBJECTUIVPROC)IntGetProcAddress("glGetQueryObjectuiv");
-    GetQueryObjectuiv(id, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindBuffer(GLenum target, GLuint buffer)
-  {
-    BindBuffer = (PFNBINDBUFFERPROC)IntGetProcAddress("glBindBuffer");
-    BindBuffer(target, buffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteBuffers(GLsizei n, const GLuint *buffers)
-  {
-    DeleteBuffers = (PFNDELETEBUFFERSPROC)IntGetProcAddress("glDeleteBuffers");
-    DeleteBuffers(n, buffers);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenBuffers(GLsizei n, GLuint *buffers)
-  {
-    GenBuffers = (PFNGENBUFFERSPROC)IntGetProcAddress("glGenBuffers");
-    GenBuffers(n, buffers);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsBuffer(GLuint buffer)
-  {
-    IsBuffer = (PFNISBUFFERPROC)IntGetProcAddress("glIsBuffer");
-    return IsBuffer(buffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
-  {
-    BufferData = (PFNBUFFERDATAPROC)IntGetProcAddress("glBufferData");
-    BufferData(target, size, data, usage);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
-  {
-    BufferSubData = (PFNBUFFERSUBDATAPROC)IntGetProcAddress("glBufferSubData");
-    BufferSubData(target, offset, size, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
-  {
-    GetBufferSubData = (PFNGETBUFFERSUBDATAPROC)IntGetProcAddress("glGetBufferSubData");
-    GetBufferSubData(target, offset, size, data);
-  }
-
-  static GLvoid* CODEGEN_FUNCPTR Switch_MapBuffer(GLenum target, GLenum access)
-  {
-    MapBuffer = (PFNMAPBUFFERPROC)IntGetProcAddress("glMapBuffer");
-    return MapBuffer(target, access);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_UnmapBuffer(GLenum target)
-  {
-    UnmapBuffer = (PFNUNMAPBUFFERPROC)IntGetProcAddress("glUnmapBuffer");
-    return UnmapBuffer(target);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
-  {
-    GetBufferParameteriv = (PFNGETBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetBufferParameteriv");
-    GetBufferParameteriv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
-  {
-    GetBufferPointerv = (PFNGETBUFFERPOINTERVPROC)IntGetProcAddress("glGetBufferPointerv");
-    GetBufferPointerv(target, pname, params);
-  }
-
-
-  // Extension: 2.0
-  static void CODEGEN_FUNCPTR Switch_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-  {
-    BlendEquationSeparate = (PFNBLENDEQUATIONSEPARATEPROC)IntGetProcAddress("glBlendEquationSeparate");
-    BlendEquationSeparate(modeRGB, modeAlpha);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawBuffers(GLsizei n, const GLenum *bufs)
-  {
-    DrawBuffers = (PFNDRAWBUFFERSPROC)IntGetProcAddress("glDrawBuffers");
-    DrawBuffers(n, bufs);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
-  {
-    StencilOpSeparate = (PFNSTENCILOPSEPARATEPROC)IntGetProcAddress("glStencilOpSeparate");
-    StencilOpSeparate(face, sfail, dpfail, dppass);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-  {
-    StencilFuncSeparate = (PFNSTENCILFUNCSEPARATEPROC)IntGetProcAddress("glStencilFuncSeparate");
-    StencilFuncSeparate(face, func, ref, mask);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_StencilMaskSeparate(GLenum face, GLuint mask)
-  {
-    StencilMaskSeparate = (PFNSTENCILMASKSEPARATEPROC)IntGetProcAddress("glStencilMaskSeparate");
-    StencilMaskSeparate(face, mask);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_AttachShader(GLuint program, GLuint shader)
-  {
-    AttachShader = (PFNATTACHSHADERPROC)IntGetProcAddress("glAttachShader");
-    AttachShader(program, shader);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
-  {
-    BindAttribLocation = (PFNBINDATTRIBLOCATIONPROC)IntGetProcAddress("glBindAttribLocation");
-    BindAttribLocation(program, index, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_CompileShader(GLuint shader)
-  {
-    CompileShader = (PFNCOMPILESHADERPROC)IntGetProcAddress("glCompileShader");
-    CompileShader(shader);
-  }
-
-  static GLuint CODEGEN_FUNCPTR Switch_CreateProgram()
-  {
-    CreateProgram = (PFNCREATEPROGRAMPROC)IntGetProcAddress("glCreateProgram");
-    return CreateProgram();
-  }
-
-  static GLuint CODEGEN_FUNCPTR Switch_CreateShader(GLenum type)
-  {
-    CreateShader = (PFNCREATESHADERPROC)IntGetProcAddress("glCreateShader");
-    return CreateShader(type);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteProgram(GLuint program)
-  {
-    DeleteProgram = (PFNDELETEPROGRAMPROC)IntGetProcAddress("glDeleteProgram");
-    DeleteProgram(program);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteShader(GLuint shader)
-  {
-    DeleteShader = (PFNDELETESHADERPROC)IntGetProcAddress("glDeleteShader");
-    DeleteShader(shader);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DetachShader(GLuint program, GLuint shader)
-  {
-    DetachShader = (PFNDETACHSHADERPROC)IntGetProcAddress("glDetachShader");
-    DetachShader(program, shader);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DisableVertexAttribArray(GLuint index)
-  {
-    DisableVertexAttribArray = (PFNDISABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glDisableVertexAttribArray");
-    DisableVertexAttribArray(index);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_EnableVertexAttribArray(GLuint index)
-  {
-    EnableVertexAttribArray = (PFNENABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glEnableVertexAttribArray");
-    EnableVertexAttribArray(index);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-  {
-    GetActiveAttrib = (PFNGETACTIVEATTRIBPROC)IntGetProcAddress("glGetActiveAttrib");
-    GetActiveAttrib(program, index, bufSize, length, size, type, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
-  {
-    GetActiveUniform = (PFNGETACTIVEUNIFORMPROC)IntGetProcAddress("glGetActiveUniform");
-    GetActiveUniform(program, index, bufSize, length, size, type, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
-  {
-    GetAttachedShaders = (PFNGETATTACHEDSHADERSPROC)IntGetProcAddress("glGetAttachedShaders");
-    GetAttachedShaders(program, maxCount, count, obj);
-  }
-
-  static GLint CODEGEN_FUNCPTR Switch_GetAttribLocation(GLuint program, const GLchar *name)
-  {
-    GetAttribLocation = (PFNGETATTRIBLOCATIONPROC)IntGetProcAddress("glGetAttribLocation");
-    return GetAttribLocation(program, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetProgramiv(GLuint program, GLenum pname, GLint *params)
-  {
-    GetProgramiv = (PFNGETPROGRAMIVPROC)IntGetProcAddress("glGetProgramiv");
-    GetProgramiv(program, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-  {
-    GetProgramInfoLog = (PFNGETPROGRAMINFOLOGPROC)IntGetProcAddress("glGetProgramInfoLog");
-    GetProgramInfoLog(program, bufSize, length, infoLog);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
-  {
-    GetShaderiv = (PFNGETSHADERIVPROC)IntGetProcAddress("glGetShaderiv");
-    GetShaderiv(shader, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
-  {
-    GetShaderInfoLog = (PFNGETSHADERINFOLOGPROC)IntGetProcAddress("glGetShaderInfoLog");
-    GetShaderInfoLog(shader, bufSize, length, infoLog);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
-  {
-    GetShaderSource = (PFNGETSHADERSOURCEPROC)IntGetProcAddress("glGetShaderSource");
-    GetShaderSource(shader, bufSize, length, source);
-  }
-
-  static GLint CODEGEN_FUNCPTR Switch_GetUniformLocation(GLuint program, const GLchar *name)
-  {
-    GetUniformLocation = (PFNGETUNIFORMLOCATIONPROC)IntGetProcAddress("glGetUniformLocation");
-    return GetUniformLocation(program, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetUniformfv(GLuint program, GLint location, GLfloat *params)
-  {
-    GetUniformfv = (PFNGETUNIFORMFVPROC)IntGetProcAddress("glGetUniformfv");
-    GetUniformfv(program, location, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetUniformiv(GLuint program, GLint location, GLint *params)
-  {
-    GetUniformiv = (PFNGETUNIFORMIVPROC)IntGetProcAddress("glGetUniformiv");
-    GetUniformiv(program, location, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
-  {
-    GetVertexAttribdv = (PFNGETVERTEXATTRIBDVPROC)IntGetProcAddress("glGetVertexAttribdv");
-    GetVertexAttribdv(index, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
-  {
-    GetVertexAttribfv = (PFNGETVERTEXATTRIBFVPROC)IntGetProcAddress("glGetVertexAttribfv");
-    GetVertexAttribfv(index, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
-  {
-    GetVertexAttribiv = (PFNGETVERTEXATTRIBIVPROC)IntGetProcAddress("glGetVertexAttribiv");
-    GetVertexAttribiv(index, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
-  {
-    GetVertexAttribPointerv = (PFNGETVERTEXATTRIBPOINTERVPROC)IntGetProcAddress("glGetVertexAttribPointerv");
-    GetVertexAttribPointerv(index, pname, pointer);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsProgram(GLuint program)
-  {
-    IsProgram = (PFNISPROGRAMPROC)IntGetProcAddress("glIsProgram");
-    return IsProgram(program);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsShader(GLuint shader)
-  {
-    IsShader = (PFNISSHADERPROC)IntGetProcAddress("glIsShader");
-    return IsShader(shader);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_LinkProgram(GLuint program)
-  {
-    LinkProgram = (PFNLINKPROGRAMPROC)IntGetProcAddress("glLinkProgram");
-    LinkProgram(program);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
-  {
-    ShaderSource = (PFNSHADERSOURCEPROC)IntGetProcAddress("glShaderSource");
-    ShaderSource(shader, count, string, length);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UseProgram(GLuint program)
-  {
-    UseProgram = (PFNUSEPROGRAMPROC)IntGetProcAddress("glUseProgram");
-    UseProgram(program);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1f(GLint location, GLfloat v0)
-  {
-    Uniform1f = (PFNUNIFORM1FPROC)IntGetProcAddress("glUniform1f");
-    Uniform1f(location, v0);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
-  {
-    Uniform2f = (PFNUNIFORM2FPROC)IntGetProcAddress("glUniform2f");
-    Uniform2f(location, v0, v1);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-  {
-    Uniform3f = (PFNUNIFORM3FPROC)IntGetProcAddress("glUniform3f");
-    Uniform3f(location, v0, v1, v2);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-  {
-    Uniform4f = (PFNUNIFORM4FPROC)IntGetProcAddress("glUniform4f");
-    Uniform4f(location, v0, v1, v2, v3);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1i(GLint location, GLint v0)
-  {
-    Uniform1i = (PFNUNIFORM1IPROC)IntGetProcAddress("glUniform1i");
-    Uniform1i(location, v0);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2i(GLint location, GLint v0, GLint v1)
-  {
-    Uniform2i = (PFNUNIFORM2IPROC)IntGetProcAddress("glUniform2i");
-    Uniform2i(location, v0, v1);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
-  {
-    Uniform3i = (PFNUNIFORM3IPROC)IntGetProcAddress("glUniform3i");
-    Uniform3i(location, v0, v1, v2);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-  {
-    Uniform4i = (PFNUNIFORM4IPROC)IntGetProcAddress("glUniform4i");
-    Uniform4i(location, v0, v1, v2, v3);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
-  {
-    Uniform1fv = (PFNUNIFORM1FVPROC)IntGetProcAddress("glUniform1fv");
-    Uniform1fv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
-  {
-    Uniform2fv = (PFNUNIFORM2FVPROC)IntGetProcAddress("glUniform2fv");
-    Uniform2fv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
-  {
-    Uniform3fv = (PFNUNIFORM3FVPROC)IntGetProcAddress("glUniform3fv");
-    Uniform3fv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
-  {
-    Uniform4fv = (PFNUNIFORM4FVPROC)IntGetProcAddress("glUniform4fv");
-    Uniform4fv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1iv(GLint location, GLsizei count, const GLint *value)
-  {
-    Uniform1iv = (PFNUNIFORM1IVPROC)IntGetProcAddress("glUniform1iv");
-    Uniform1iv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2iv(GLint location, GLsizei count, const GLint *value)
-  {
-    Uniform2iv = (PFNUNIFORM2IVPROC)IntGetProcAddress("glUniform2iv");
-    Uniform2iv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3iv(GLint location, GLsizei count, const GLint *value)
-  {
-    Uniform3iv = (PFNUNIFORM3IVPROC)IntGetProcAddress("glUniform3iv");
-    Uniform3iv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4iv(GLint location, GLsizei count, const GLint *value)
-  {
-    Uniform4iv = (PFNUNIFORM4IVPROC)IntGetProcAddress("glUniform4iv");
-    Uniform4iv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix2fv = (PFNUNIFORMMATRIX2FVPROC)IntGetProcAddress("glUniformMatrix2fv");
-    UniformMatrix2fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix3fv = (PFNUNIFORMMATRIX3FVPROC)IntGetProcAddress("glUniformMatrix3fv");
-    UniformMatrix3fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix4fv = (PFNUNIFORMMATRIX4FVPROC)IntGetProcAddress("glUniformMatrix4fv");
-    UniformMatrix4fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ValidateProgram(GLuint program)
-  {
-    ValidateProgram = (PFNVALIDATEPROGRAMPROC)IntGetProcAddress("glValidateProgram");
-    ValidateProgram(program);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
-  {
-    VertexAttribPointer = (PFNVERTEXATTRIBPOINTERPROC)IntGetProcAddress("glVertexAttribPointer");
-    VertexAttribPointer(index, size, type, normalized, stride, pointer);
-  }
-
-
-  // Extension: 2.1
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix2x3fv = (PFNUNIFORMMATRIX2X3FVPROC)IntGetProcAddress("glUniformMatrix2x3fv");
-    UniformMatrix2x3fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix3x2fv = (PFNUNIFORMMATRIX3X2FVPROC)IntGetProcAddress("glUniformMatrix3x2fv");
-    UniformMatrix3x2fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix2x4fv = (PFNUNIFORMMATRIX2X4FVPROC)IntGetProcAddress("glUniformMatrix2x4fv");
-    UniformMatrix2x4fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix4x2fv = (PFNUNIFORMMATRIX4X2FVPROC)IntGetProcAddress("glUniformMatrix4x2fv");
-    UniformMatrix4x2fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix3x4fv = (PFNUNIFORMMATRIX3X4FVPROC)IntGetProcAddress("glUniformMatrix3x4fv");
-    UniformMatrix3x4fv(location, count, transpose, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
-  {
-    UniformMatrix4x3fv = (PFNUNIFORMMATRIX4X3FVPROC)IntGetProcAddress("glUniformMatrix4x3fv");
-    UniformMatrix4x3fv(location, count, transpose, value);
-  }
-
-
-  // Extension: ARB_vertex_array_object
-  static void CODEGEN_FUNCPTR Switch_BindVertexArray(GLuint ren_array)
-  {
-    BindVertexArray = (PFNBINDVERTEXARRAYPROC)IntGetProcAddress("glBindVertexArray");
-    BindVertexArray(ren_array);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteVertexArrays(GLsizei n, const GLuint *arrays)
-  {
-    DeleteVertexArrays = (PFNDELETEVERTEXARRAYSPROC)IntGetProcAddress("glDeleteVertexArrays");
-    DeleteVertexArrays(n, arrays);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenVertexArrays(GLsizei n, GLuint *arrays)
-  {
-    GenVertexArrays = (PFNGENVERTEXARRAYSPROC)IntGetProcAddress("glGenVertexArrays");
-    GenVertexArrays(n, arrays);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsVertexArray(GLuint ren_array)
-  {
-    IsVertexArray = (PFNISVERTEXARRAYPROC)IntGetProcAddress("glIsVertexArray");
-    return IsVertexArray(ren_array);
-  }
-
-
-  // Extension: ARB_map_buffer_range
-  static GLvoid* CODEGEN_FUNCPTR Switch_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-  {
-    MapBufferRange = (PFNMAPBUFFERRANGEPROC)IntGetProcAddress("glMapBufferRange");
-    return MapBufferRange(target, offset, length, access);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-  {
-    FlushMappedBufferRange = (PFNFLUSHMAPPEDBUFFERRANGEPROC)IntGetProcAddress("glFlushMappedBufferRange");
-    FlushMappedBufferRange(target, offset, length);
-  }
-
-
-  // Extension: ARB_framebuffer_object
-  static GLboolean CODEGEN_FUNCPTR Switch_IsRenderbuffer(GLuint renderbuffer)
-  {
-    IsRenderbuffer = (PFNISRENDERBUFFERPROC)IntGetProcAddress("glIsRenderbuffer");
-    return IsRenderbuffer(renderbuffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindRenderbuffer(GLenum target, GLuint renderbuffer)
-  {
-    BindRenderbuffer = (PFNBINDRENDERBUFFERPROC)IntGetProcAddress("glBindRenderbuffer");
-    BindRenderbuffer(target, renderbuffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
-  {
-    DeleteRenderbuffers = (PFNDELETERENDERBUFFERSPROC)IntGetProcAddress("glDeleteRenderbuffers");
-    DeleteRenderbuffers(n, renderbuffers);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
-  {
-    GenRenderbuffers = (PFNGENRENDERBUFFERSPROC)IntGetProcAddress("glGenRenderbuffers");
-    GenRenderbuffers(n, renderbuffers);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-  {
-    RenderbufferStorage = (PFNRENDERBUFFERSTORAGEPROC)IntGetProcAddress("glRenderbufferStorage");
-    RenderbufferStorage(target, internalformat, width, height);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
-  {
-    GetRenderbufferParameteriv = (PFNGETRENDERBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetRenderbufferParameteriv");
-    GetRenderbufferParameteriv(target, pname, params);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsFramebuffer(GLuint framebuffer)
-  {
-    IsFramebuffer = (PFNISFRAMEBUFFERPROC)IntGetProcAddress("glIsFramebuffer");
-    return IsFramebuffer(framebuffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindFramebuffer(GLenum target, GLuint framebuffer)
-  {
-    BindFramebuffer = (PFNBINDFRAMEBUFFERPROC)IntGetProcAddress("glBindFramebuffer");
-    BindFramebuffer(target, framebuffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
-  {
-    DeleteFramebuffers = (PFNDELETEFRAMEBUFFERSPROC)IntGetProcAddress("glDeleteFramebuffers");
-    DeleteFramebuffers(n, framebuffers);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenFramebuffers(GLsizei n, GLuint *framebuffers)
-  {
-    GenFramebuffers = (PFNGENFRAMEBUFFERSPROC)IntGetProcAddress("glGenFramebuffers");
-    GenFramebuffers(n, framebuffers);
-  }
-
-  static GLenum CODEGEN_FUNCPTR Switch_CheckFramebufferStatus(GLenum target)
-  {
-    CheckFramebufferStatus = (PFNCHECKFRAMEBUFFERSTATUSPROC)IntGetProcAddress("glCheckFramebufferStatus");
-    return CheckFramebufferStatus(target);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-  {
-    FramebufferTexture1D = (PFNFRAMEBUFFERTEXTURE1DPROC)IntGetProcAddress("glFramebufferTexture1D");
-    FramebufferTexture1D(target, attachment, textarget, texture, level);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-  {
-    FramebufferTexture2D = (PFNFRAMEBUFFERTEXTURE2DPROC)IntGetProcAddress("glFramebufferTexture2D");
-    FramebufferTexture2D(target, attachment, textarget, texture, level);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
-  {
-    FramebufferTexture3D = (PFNFRAMEBUFFERTEXTURE3DPROC)IntGetProcAddress("glFramebufferTexture3D");
-    FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-  {
-    FramebufferRenderbuffer = (PFNFRAMEBUFFERRENDERBUFFERPROC)IntGetProcAddress("glFramebufferRenderbuffer");
-    FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
-  {
-    GetFramebufferAttachmentParameteriv = (PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)IntGetProcAddress("glGetFramebufferAttachmentParameteriv");
-    GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GenerateMipmap(GLenum target)
-  {
-    GenerateMipmap = (PFNGENERATEMIPMAPPROC)IntGetProcAddress("glGenerateMipmap");
-    GenerateMipmap(target);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-  {
-    BlitFramebuffer = (PFNBLITFRAMEBUFFERPROC)IntGetProcAddress("glBlitFramebuffer");
-    BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-  {
-    RenderbufferStorageMultisample = (PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)IntGetProcAddress("glRenderbufferStorageMultisample");
-    RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-  {
-    FramebufferTextureLayer = (PFNFRAMEBUFFERTEXTURELAYERPROC)IntGetProcAddress("glFramebufferTextureLayer");
-    FramebufferTextureLayer(target, attachment, texture, level, layer);
-  }
-
-
-  // Extension: 3.0
-  static void CODEGEN_FUNCPTR Switch_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
-  {
-    ColorMaski = (PFNCOLORMASKIPROC)IntGetProcAddress("glColorMaski");
-    ColorMaski(index, r, g, b, a);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-  {
-    GetBooleani_v = (PFNGETBOOLEANI_VPROC)IntGetProcAddress("glGetBooleani_v");
-    GetBooleani_v(target, index, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetIntegeri_v(GLenum target, GLuint index, GLint *data)
-  {
-    GetIntegeri_v = (PFNGETINTEGERI_VPROC)IntGetProcAddress("glGetIntegeri_v");
-    GetIntegeri_v(target, index, data);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Enablei(GLenum target, GLuint index)
-  {
-    Enablei = (PFNENABLEIPROC)IntGetProcAddress("glEnablei");
-    Enablei(target, index);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Disablei(GLenum target, GLuint index)
-  {
-    Disablei = (PFNDISABLEIPROC)IntGetProcAddress("glDisablei");
-    Disablei(target, index);
-  }
-
-  static GLboolean CODEGEN_FUNCPTR Switch_IsEnabledi(GLenum target, GLuint index)
-  {
-    IsEnabledi = (PFNISENABLEDIPROC)IntGetProcAddress("glIsEnabledi");
-    return IsEnabledi(target, index);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BeginTransformFeedback(GLenum primitiveMode)
-  {
-    BeginTransformFeedback = (PFNBEGINTRANSFORMFEEDBACKPROC)IntGetProcAddress("glBeginTransformFeedback");
-    BeginTransformFeedback(primitiveMode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_EndTransformFeedback()
-  {
-    EndTransformFeedback = (PFNENDTRANSFORMFEEDBACKPROC)IntGetProcAddress("glEndTransformFeedback");
-    EndTransformFeedback();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-  {
-    BindBufferRange = (PFNBINDBUFFERRANGEPROC)IntGetProcAddress("glBindBufferRange");
-    BindBufferRange(target, index, buffer, offset, size);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
-  {
-    BindBufferBase = (PFNBINDBUFFERBASEPROC)IntGetProcAddress("glBindBufferBase");
-    BindBufferBase(target, index, buffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
-  {
-    TransformFeedbackVaryings = (PFNTRANSFORMFEEDBACKVARYINGSPROC)IntGetProcAddress("glTransformFeedbackVaryings");
-    TransformFeedbackVaryings(program, count, varyings, bufferMode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
-  {
-    GetTransformFeedbackVarying = (PFNGETTRANSFORMFEEDBACKVARYINGPROC)IntGetProcAddress("glGetTransformFeedbackVarying");
-    GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClampColor(GLenum target, GLenum clamp)
-  {
-    ClampColor = (PFNCLAMPCOLORPROC)IntGetProcAddress("glClampColor");
-    ClampColor(target, clamp);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BeginConditionalRender(GLuint id, GLenum mode)
-  {
-    BeginConditionalRender = (PFNBEGINCONDITIONALRENDERPROC)IntGetProcAddress("glBeginConditionalRender");
-    BeginConditionalRender(id, mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_EndConditionalRender()
-  {
-    EndConditionalRender = (PFNENDCONDITIONALRENDERPROC)IntGetProcAddress("glEndConditionalRender");
-    EndConditionalRender();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
-  {
-    VertexAttribIPointer = (PFNVERTEXATTRIBIPOINTERPROC)IntGetProcAddress("glVertexAttribIPointer");
-    VertexAttribIPointer(index, size, type, stride, pointer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
-  {
-    GetVertexAttribIiv = (PFNGETVERTEXATTRIBIIVPROC)IntGetProcAddress("glGetVertexAttribIiv");
-    GetVertexAttribIiv(index, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
-  {
-    GetVertexAttribIuiv = (PFNGETVERTEXATTRIBIUIVPROC)IntGetProcAddress("glGetVertexAttribIuiv");
-    GetVertexAttribIuiv(index, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI1i(GLuint index, GLint x)
-  {
-    VertexAttribI1i = (PFNVERTEXATTRIBI1IPROC)IntGetProcAddress("glVertexAttribI1i");
-    VertexAttribI1i(index, x);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI2i(GLuint index, GLint x, GLint y)
-  {
-    VertexAttribI2i = (PFNVERTEXATTRIBI2IPROC)IntGetProcAddress("glVertexAttribI2i");
-    VertexAttribI2i(index, x, y);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
-  {
-    VertexAttribI3i = (PFNVERTEXATTRIBI3IPROC)IntGetProcAddress("glVertexAttribI3i");
-    VertexAttribI3i(index, x, y, z);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-  {
-    VertexAttribI4i = (PFNVERTEXATTRIBI4IPROC)IntGetProcAddress("glVertexAttribI4i");
-    VertexAttribI4i(index, x, y, z, w);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI1ui(GLuint index, GLuint x)
-  {
-    VertexAttribI1ui = (PFNVERTEXATTRIBI1UIPROC)IntGetProcAddress("glVertexAttribI1ui");
-    VertexAttribI1ui(index, x);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
-  {
-    VertexAttribI2ui = (PFNVERTEXATTRIBI2UIPROC)IntGetProcAddress("glVertexAttribI2ui");
-    VertexAttribI2ui(index, x, y);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
-  {
-    VertexAttribI3ui = (PFNVERTEXATTRIBI3UIPROC)IntGetProcAddress("glVertexAttribI3ui");
-    VertexAttribI3ui(index, x, y, z);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-  {
-    VertexAttribI4ui = (PFNVERTEXATTRIBI4UIPROC)IntGetProcAddress("glVertexAttribI4ui");
-    VertexAttribI4ui(index, x, y, z, w);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI1iv(GLuint index, const GLint *v)
-  {
-    VertexAttribI1iv = (PFNVERTEXATTRIBI1IVPROC)IntGetProcAddress("glVertexAttribI1iv");
-    VertexAttribI1iv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI2iv(GLuint index, const GLint *v)
-  {
-    VertexAttribI2iv = (PFNVERTEXATTRIBI2IVPROC)IntGetProcAddress("glVertexAttribI2iv");
-    VertexAttribI2iv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI3iv(GLuint index, const GLint *v)
-  {
-    VertexAttribI3iv = (PFNVERTEXATTRIBI3IVPROC)IntGetProcAddress("glVertexAttribI3iv");
-    VertexAttribI3iv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4iv(GLuint index, const GLint *v)
-  {
-    VertexAttribI4iv = (PFNVERTEXATTRIBI4IVPROC)IntGetProcAddress("glVertexAttribI4iv");
-    VertexAttribI4iv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI1uiv(GLuint index, const GLuint *v)
-  {
-    VertexAttribI1uiv = (PFNVERTEXATTRIBI1UIVPROC)IntGetProcAddress("glVertexAttribI1uiv");
-    VertexAttribI1uiv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI2uiv(GLuint index, const GLuint *v)
-  {
-    VertexAttribI2uiv = (PFNVERTEXATTRIBI2UIVPROC)IntGetProcAddress("glVertexAttribI2uiv");
-    VertexAttribI2uiv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI3uiv(GLuint index, const GLuint *v)
-  {
-    VertexAttribI3uiv = (PFNVERTEXATTRIBI3UIVPROC)IntGetProcAddress("glVertexAttribI3uiv");
-    VertexAttribI3uiv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4uiv(GLuint index, const GLuint *v)
-  {
-    VertexAttribI4uiv = (PFNVERTEXATTRIBI4UIVPROC)IntGetProcAddress("glVertexAttribI4uiv");
-    VertexAttribI4uiv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4bv(GLuint index, const GLbyte *v)
-  {
-    VertexAttribI4bv = (PFNVERTEXATTRIBI4BVPROC)IntGetProcAddress("glVertexAttribI4bv");
-    VertexAttribI4bv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4sv(GLuint index, const GLshort *v)
-  {
-    VertexAttribI4sv = (PFNVERTEXATTRIBI4SVPROC)IntGetProcAddress("glVertexAttribI4sv");
-    VertexAttribI4sv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4ubv(GLuint index, const GLubyte *v)
-  {
-    VertexAttribI4ubv = (PFNVERTEXATTRIBI4UBVPROC)IntGetProcAddress("glVertexAttribI4ubv");
-    VertexAttribI4ubv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexAttribI4usv(GLuint index, const GLushort *v)
-  {
-    VertexAttribI4usv = (PFNVERTEXATTRIBI4USVPROC)IntGetProcAddress("glVertexAttribI4usv");
-    VertexAttribI4usv(index, v);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetUniformuiv(GLuint program, GLint location, GLuint *params)
-  {
-    GetUniformuiv = (PFNGETUNIFORMUIVPROC)IntGetProcAddress("glGetUniformuiv");
-    GetUniformuiv(program, location, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
-  {
-    BindFragDataLocation = (PFNBINDFRAGDATALOCATIONPROC)IntGetProcAddress("glBindFragDataLocation");
-    BindFragDataLocation(program, color, name);
-  }
-
-  static GLint CODEGEN_FUNCPTR Switch_GetFragDataLocation(GLuint program, const GLchar *name)
-  {
-    GetFragDataLocation = (PFNGETFRAGDATALOCATIONPROC)IntGetProcAddress("glGetFragDataLocation");
-    return GetFragDataLocation(program, name);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1ui(GLint location, GLuint v0)
-  {
-    Uniform1ui = (PFNUNIFORM1UIPROC)IntGetProcAddress("glUniform1ui");
-    Uniform1ui(location, v0);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2ui(GLint location, GLuint v0, GLuint v1)
-  {
-    Uniform2ui = (PFNUNIFORM2UIPROC)IntGetProcAddress("glUniform2ui");
-    Uniform2ui(location, v0, v1);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-  {
-    Uniform3ui = (PFNUNIFORM3UIPROC)IntGetProcAddress("glUniform3ui");
-    Uniform3ui(location, v0, v1, v2);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-  {
-    Uniform4ui = (PFNUNIFORM4UIPROC)IntGetProcAddress("glUniform4ui");
-    Uniform4ui(location, v0, v1, v2, v3);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
-  {
-    Uniform1uiv = (PFNUNIFORM1UIVPROC)IntGetProcAddress("glUniform1uiv");
-    Uniform1uiv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
-  {
-    Uniform2uiv = (PFNUNIFORM2UIVPROC)IntGetProcAddress("glUniform2uiv");
-    Uniform2uiv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
-  {
-    Uniform3uiv = (PFNUNIFORM3UIVPROC)IntGetProcAddress("glUniform3uiv");
-    Uniform3uiv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
-  {
-    Uniform4uiv = (PFNUNIFORM4UIVPROC)IntGetProcAddress("glUniform4uiv");
-    Uniform4uiv(location, count, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
-  {
-    TexParameterIiv = (PFNTEXPARAMETERIIVPROC)IntGetProcAddress("glTexParameterIiv");
-    TexParameterIiv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
-  {
-    TexParameterIuiv = (PFNTEXPARAMETERIUIVPROC)IntGetProcAddress("glTexParameterIuiv");
-    TexParameterIuiv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
-  {
-    GetTexParameterIiv = (PFNGETTEXPARAMETERIIVPROC)IntGetProcAddress("glGetTexParameterIiv");
-    GetTexParameterIiv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
-  {
-    GetTexParameterIuiv = (PFNGETTEXPARAMETERIUIVPROC)IntGetProcAddress("glGetTexParameterIuiv");
-    GetTexParameterIuiv(target, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
-  {
-    ClearBufferiv = (PFNCLEARBUFFERIVPROC)IntGetProcAddress("glClearBufferiv");
-    ClearBufferiv(buffer, drawbuffer, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
-  {
-    ClearBufferuiv = (PFNCLEARBUFFERUIVPROC)IntGetProcAddress("glClearBufferuiv");
-    ClearBufferuiv(buffer, drawbuffer, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
-  {
-    ClearBufferfv = (PFNCLEARBUFFERFVPROC)IntGetProcAddress("glClearBufferfv");
-    ClearBufferfv(buffer, drawbuffer, value);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-  {
-    ClearBufferfi = (PFNCLEARBUFFERFIPROC)IntGetProcAddress("glClearBufferfi");
-    ClearBufferfi(buffer, drawbuffer, depth, stencil);
-  }
-
-  static const GLubyte * CODEGEN_FUNCPTR Switch_GetStringi(GLenum name, GLuint index)
-  {
-    GetStringi = (PFNGETSTRINGIPROC)IntGetProcAddress("glGetStringi");
-    return GetStringi(name, index);
-  }
-
-
-  // Extension: ARB_uniform_buffer_object
-  static void CODEGEN_FUNCPTR Switch_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
-  {
-    GetUniformIndices = (PFNGETUNIFORMINDICESPROC)IntGetProcAddress("glGetUniformIndices");
-    GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
-  {
-    GetActiveUniformsiv = (PFNGETACTIVEUNIFORMSIVPROC)IntGetProcAddress("glGetActiveUniformsiv");
-    GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
-  {
-    GetActiveUniformName = (PFNGETACTIVEUNIFORMNAMEPROC)IntGetProcAddress("glGetActiveUniformName");
-    GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
-  }
-
-  static GLuint CODEGEN_FUNCPTR Switch_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
-  {
-    GetUniformBlockIndex = (PFNGETUNIFORMBLOCKINDEXPROC)IntGetProcAddress("glGetUniformBlockIndex");
-    return GetUniformBlockIndex(program, uniformBlockName);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
-  {
-    GetActiveUniformBlockiv = (PFNGETACTIVEUNIFORMBLOCKIVPROC)IntGetProcAddress("glGetActiveUniformBlockiv");
-    GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
-  {
-    GetActiveUniformBlockName = (PFNGETACTIVEUNIFORMBLOCKNAMEPROC)IntGetProcAddress("glGetActiveUniformBlockName");
-    GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-  {
-    UniformBlockBinding = (PFNUNIFORMBLOCKBINDINGPROC)IntGetProcAddress("glUniformBlockBinding");
-    UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-  }
-
-
-  // Extension: ARB_copy_buffer
-  static void CODEGEN_FUNCPTR Switch_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-  {
-    CopyBufferSubData = (PFNCOPYBUFFERSUBDATAPROC)IntGetProcAddress("glCopyBufferSubData");
-    CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-  }
-
-
-  // Extension: 3.1
-  static void CODEGEN_FUNCPTR Switch_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-  {
-    DrawArraysInstanced = (PFNDRAWARRAYSINSTANCEDPROC)IntGetProcAddress("glDrawArraysInstanced");
-    DrawArraysInstanced(mode, first, count, instancecount);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
-  {
-    DrawElementsInstanced = (PFNDRAWELEMENTSINSTANCEDPROC)IntGetProcAddress("glDrawElementsInstanced");
-    DrawElementsInstanced(mode, count, type, indices, instancecount);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
-  {
-    TexBuffer = (PFNTEXBUFFERPROC)IntGetProcAddress("glTexBuffer");
-    TexBuffer(target, internalformat, buffer);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_PrimitiveRestartIndex(GLuint index)
-  {
-    PrimitiveRestartIndex = (PFNPRIMITIVERESTARTINDEXPROC)IntGetProcAddress("glPrimitiveRestartIndex");
-    PrimitiveRestartIndex(index);
-  }
-
-  // Legacy
-  static void CODEGEN_FUNCPTR Switch_EnableClientState(GLenum cap)
-  {
-    EnableClientState = (PFNENABLECLIENTSTATEPROC)IntGetProcAddress("glEnableClientState");
-    EnableClientState(cap);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_DisableClientState(GLenum cap)
-  {
-    DisableClientState = (PFNDISABLECLIENTSTATEPROC)IntGetProcAddress("glDisableClientState");
-    DisableClientState(cap);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
-  {
-    VertexPointer = (PFNVERTEXPOINTERPROC)IntGetProcAddress("glVertexPointer");
-    VertexPointer(size, type, stride, ptr);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
-  {
-    NormalPointer = (PFNNORMALPOINTERPROC)IntGetProcAddress("glNormalPointer");
-    NormalPointer(type, stride, ptr);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
-  {
-    ColorPointer = (PFNCOLORPOINTERPROC)IntGetProcAddress("glColorPointer");
-    ColorPointer(size, type, stride, ptr);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
-  {
-    TexCoordPointer = (PFNTEXCOORDPOINTERPROC)IntGetProcAddress("glTexCoordPointer");
-    TexCoordPointer(size, type, stride, ptr);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_TexEnvi(GLenum target, GLenum pname, GLint param)
-  {
-    TexEnvi = (PFNTEXENVIPROC)IntGetProcAddress("glTexEnvi");
-    TexEnvi(target, pname, param);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_MatrixMode(GLenum mode)
-  {
-    MatrixMode = (PFNMATRIXMODEPROC)IntGetProcAddress("glMatrixMode");
-    MatrixMode(mode);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_LoadIdentity(void)
-  {
-    LoadIdentity = (PFNLOADIDENTITYPROC)IntGetProcAddress("glLoadIdentity");
-    LoadIdentity();
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)
-  {
-    Ortho = (PFNORTHOPROC)IntGetProcAddress("glOrtho");
-    Ortho(left, right, bottom, top, near_val, far_val);
-  }
-
-  static void CODEGEN_FUNCPTR Switch_Color3d(GLdouble red, GLdouble green, GLdouble blue)
-  {
-    Color3d = (PFNCOLOR3DPROC)IntGetProcAddress("glColor3d");
-    Color3d(red, green, blue);
-  }
-
-
-
-  namespace
-  {
+    //////////////////////////////////////////////
+    // Function pointer types
+
+    // Extension: 1.1
+    typedef void (CODEGEN_FUNCPTR *PFNCULLFACEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNFRONTFACEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNHINTPROC)(GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNLINEWIDTHPROC)(GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNPOINTSIZEPROC)(GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNPOLYGONMODEPROC)(GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNSCISSORPROC)(GLint , GLint , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIPROC)(GLenum , GLenum , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARPROC)(GLbitfield );
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARSTENCILPROC)(GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARDEPTHPROC)(GLdouble );
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean );
+    typedef void (CODEGEN_FUNCPTR *PFNDEPTHMASKPROC)(GLboolean );
+    typedef void (CODEGEN_FUNCPTR *PFNDISABLEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNENABLEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNFINISHPROC)();
+    typedef void (CODEGEN_FUNCPTR *PFNFLUSHPROC)();
+    typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCPROC)(GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNLOGICOPPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCPROC)(GLenum , GLint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPPROC)(GLenum , GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDEPTHFUNCPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREFPROC)(GLenum , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREIPROC)(GLenum , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNREADBUFFERPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANVPROC)(GLenum , GLboolean *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETDOUBLEVPROC)(GLenum , GLdouble *);
+    typedef GLenum (CODEGEN_FUNCPTR *PFNGETERRORPROC)();
+    typedef void (CODEGEN_FUNCPTR *PFNGETFLOATVPROC)(GLenum , GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERVPROC)(GLenum , GLint *);
+    typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDEPTHRANGEPROC)(GLdouble , GLdouble );
+    typedef void (CODEGEN_FUNCPTR *PFNVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSPROC)(GLenum , GLint , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETPOINTERVPROC)(GLenum , GLvoid* *);
+    typedef void (CODEGEN_FUNCPTR *PFNPOLYGONOFFSETPROC)(GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNBINDTEXTUREPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETETEXTURESPROC)(GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENTEXTURESPROC)(GLsizei , GLuint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISTEXTUREPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNINDEXUBPROC)(GLubyte );
+    typedef void (CODEGEN_FUNCPTR *PFNINDEXUBVPROC)(const GLubyte *);
+
+    // Extension: 1.2
+    typedef void (CODEGEN_FUNCPTR *PFNBLENDCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWRANGEELEMENTSPROC)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei );
+
+    // Extension: 1.3
+    typedef void (CODEGEN_FUNCPTR *PFNACTIVETEXTUREPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNSAMPLECOVERAGEPROC)(GLfloat , GLboolean );
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE3DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETCOMPRESSEDTEXIMAGEPROC)(GLenum , GLint , GLvoid *);
+
+    // Extension: 1.4
+    typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWARRAYSPROC)(GLenum , const GLint *, const GLsizei *, GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWELEMENTSPROC)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFPROC)(GLenum , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFVPROC)(GLenum , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIPROC)(GLenum , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIVPROC)(GLenum , const GLint *);
+
+    // Extension: 1.5
+    typedef void (CODEGEN_FUNCPTR *PFNGENQUERIESPROC)(GLsizei , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNDELETEQUERIESPROC)(GLsizei , const GLuint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISQUERYPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBEGINQUERYPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNENDQUERYPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNGETQUERYIVPROC)(GLenum , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTIVPROC)(GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTUIVPROC)(GLuint , GLenum , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETEBUFFERSPROC)(GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENBUFFERSPROC)(GLsizei , GLuint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISBUFFERPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBUFFERDATAPROC)(GLenum , GLsizeiptr , const GLvoid *, GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , GLvoid *);
+    typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERPROC)(GLenum , GLenum );
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNUNMAPBUFFERPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPOINTERVPROC)(GLenum , GLenum , GLvoid* *);
+
+    // Extension: 2.0
+    typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONSEPARATEPROC)(GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERSPROC)(GLsizei , const GLenum *);
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCSEPARATEPROC)(GLenum , GLenum , GLint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKSEPARATEPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNATTACHSHADERPROC)(GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBINDATTRIBLOCATIONPROC)(GLuint , GLuint , const GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOMPILESHADERPROC)(GLuint );
+    typedef GLuint (CODEGEN_FUNCPTR *PFNCREATEPROGRAMPROC)();
+    typedef GLuint (CODEGEN_FUNCPTR *PFNCREATESHADERPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETEPROGRAMPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETESHADERPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDETACHSHADERPROC)(GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDISABLEVERTEXATTRIBARRAYPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNENABLEVERTEXATTRIBARRAYPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEATTRIBPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETATTACHEDSHADERSPROC)(GLuint , GLsizei , GLsizei *, GLuint *);
+    typedef GLint (CODEGEN_FUNCPTR *PFNGETATTRIBLOCATIONPROC)(GLuint , const GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMIVPROC)(GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETSHADERIVPROC)(GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETSHADERINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETSHADERSOURCEPROC)(GLuint , GLsizei , GLsizei *, GLchar *);
+    typedef GLint (CODEGEN_FUNCPTR *PFNGETUNIFORMLOCATIONPROC)(GLuint , const GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMFVPROC)(GLuint , GLint , GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMIVPROC)(GLuint , GLint , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBDVPROC)(GLuint , GLenum , GLdouble *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBFVPROC)(GLuint , GLenum , GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIVPROC)(GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBPOINTERVPROC)(GLuint , GLenum , GLvoid* *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISPROGRAMPROC)(GLuint );
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISSHADERPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNLINKPROGRAMPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNSHADERSOURCEPROC)(GLuint , GLsizei , const GLchar* const *, const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUSEPROGRAMPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FPROC)(GLint , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FPROC)(GLint , GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FPROC)(GLint , GLfloat , GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FPROC)(GLint , GLfloat , GLfloat , GLfloat , GLfloat );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IPROC)(GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IPROC)(GLint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IPROC)(GLint , GLint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IPROC)(GLint , GLint , GLint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FVPROC)(GLint , GLsizei , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FVPROC)(GLint , GLsizei , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FVPROC)(GLint , GLsizei , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FVPROC)(GLint , GLsizei , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IVPROC)(GLint , GLsizei , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IVPROC)(GLint , GLsizei , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IVPROC)(GLint , GLsizei , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IVPROC)(GLint , GLsizei , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNVALIDATEPROGRAMPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBPOINTERPROC)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *);
+
+    // Extension: 2.1
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *);
+
+    // Extension: ARB_vertex_array_object
+    typedef void (CODEGEN_FUNCPTR *PFNBINDVERTEXARRAYPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETEVERTEXARRAYSPROC)(GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENVERTEXARRAYSPROC)(GLsizei , GLuint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISVERTEXARRAYPROC)(GLuint );
+
+    // Extension: ARB_map_buffer_range
+    typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr , GLbitfield );
+    typedef void (CODEGEN_FUNCPTR *PFNFLUSHMAPPEDBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr );
+
+    // Extension: ARB_framebuffer_object
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISRENDERBUFFERPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBINDRENDERBUFFERPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETERENDERBUFFERSPROC)(GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENRENDERBUFFERSPROC)(GLsizei , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEPROC)(GLenum , GLenum , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNGETRENDERBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *);
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISFRAMEBUFFERPROC)(GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBINDFRAMEBUFFERPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDELETEFRAMEBUFFERSPROC)(GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENFRAMEBUFFERSPROC)(GLsizei , GLuint *);
+    typedef GLenum (CODEGEN_FUNCPTR *PFNCHECKFRAMEBUFFERSTATUSPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE1DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE2DPROC)(GLenum , GLenum , GLenum , GLuint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE3DPROC)(GLenum , GLenum , GLenum , GLuint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERRENDERBUFFERPROC)(GLenum , GLenum , GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum , GLenum , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGENERATEMIPMAPPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNBLITFRAMEBUFFERPROC)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum , GLsizei , GLenum , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURELAYERPROC)(GLenum , GLenum , GLuint , GLint , GLint );
+
+    // Extension: 3.0
+    typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKIPROC)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean );
+    typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANI_VPROC)(GLenum , GLuint , GLboolean *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERI_VPROC)(GLenum , GLuint , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNENABLEIPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNDISABLEIPROC)(GLenum , GLuint );
+    typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDIPROC)(GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNBEGINTRANSFORMFEEDBACKPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNENDTRANSFORMFEEDBACKPROC)();
+    typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERRANGEPROC)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr );
+    typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERBASEPROC)(GLenum , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNTRANSFORMFEEDBACKVARYINGSPROC)(GLuint , GLsizei , const GLchar* const *, GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNCLAMPCOLORPROC)(GLenum , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNBEGINCONDITIONALRENDERPROC)(GLuint , GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNENDCONDITIONALRENDERPROC)();
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBIPOINTERPROC)(GLuint , GLint , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIIVPROC)(GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIUIVPROC)(GLuint , GLenum , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IPROC)(GLuint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IPROC)(GLuint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IPROC)(GLuint , GLint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IPROC)(GLuint , GLint , GLint , GLint , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIPROC)(GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIPROC)(GLuint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIPROC)(GLuint , GLuint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIPROC)(GLuint , GLuint , GLuint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IVPROC)(GLuint , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IVPROC)(GLuint , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IVPROC)(GLuint , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IVPROC)(GLuint , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIVPROC)(GLuint , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIVPROC)(GLuint , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIVPROC)(GLuint , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIVPROC)(GLuint , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4BVPROC)(GLuint , const GLbyte *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4SVPROC)(GLuint , const GLshort *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UBVPROC)(GLuint , const GLubyte *);
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4USVPROC)(GLuint , const GLushort *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMUIVPROC)(GLuint , GLint , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNBINDFRAGDATALOCATIONPROC)(GLuint , GLuint , const GLchar *);
+    typedef GLint (CODEGEN_FUNCPTR *PFNGETFRAGDATALOCATIONPROC)(GLuint , const GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIPROC)(GLint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIPROC)(GLint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIPROC)(GLint , GLuint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIPROC)(GLint , GLuint , GLuint , GLuint , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIVPROC)(GLint , GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIVPROC)(GLint , GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIVPROC)(GLint , GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIVPROC)(GLint , GLsizei , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIIVPROC)(GLenum , GLenum , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIUIVPROC)(GLenum , GLenum , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIIVPROC)(GLenum , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIUIVPROC)(GLenum , GLenum , GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERIVPROC)(GLenum , GLint , const GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERUIVPROC)(GLenum , GLint , const GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFVPROC)(GLenum , GLint , const GLfloat *);
+    typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFIPROC)(GLenum , GLint , GLfloat , GLint );
+    typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGIPROC)(GLenum , GLuint );
+
+    // Extension: ARB_uniform_buffer_object
+    typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMINDICESPROC)(GLuint , GLsizei , const GLchar* const *, GLuint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMSIVPROC)(GLuint , GLsizei , const GLuint *, GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
+    typedef GLuint (CODEGEN_FUNCPTR *PFNGETUNIFORMBLOCKINDEXPROC)(GLuint , const GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKIVPROC)(GLuint , GLuint , GLenum , GLint *);
+    typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *);
+    typedef void (CODEGEN_FUNCPTR *PFNUNIFORMBLOCKBINDINGPROC)(GLuint , GLuint , GLuint );
+
+    // Extension: ARB_copy_buffer
+    typedef void (CODEGEN_FUNCPTR *PFNCOPYBUFFERSUBDATAPROC)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr );
+
+    // Extension: 3.1
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSINSTANCEDPROC)(GLenum , GLint , GLsizei , GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSINSTANCEDPROC)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei );
+    typedef void (CODEGEN_FUNCPTR *PFNTEXBUFFERPROC)(GLenum , GLenum , GLuint );
+    typedef void (CODEGEN_FUNCPTR *PFNPRIMITIVERESTARTINDEXPROC)(GLuint );
+
+    // Legacy
+    typedef void (CODEGEN_FUNCPTR *PFNENABLECLIENTSTATEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNDISABLECLIENTSTATEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNVERTEXPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNNORMALPOINTERPROC)(GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNCOLORPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXCOORDPOINTERPROC)(GLint , GLenum , GLsizei , const GLvoid *);
+    typedef void (CODEGEN_FUNCPTR *PFNTEXENVIPROC)(GLenum , GLenum , GLint );
+    typedef void (CODEGEN_FUNCPTR *PFNMATRIXMODEPROC)(GLenum );
+    typedef void (CODEGEN_FUNCPTR *PFNLOADIDENTITYPROC)(void);
+    typedef void (CODEGEN_FUNCPTR *PFNORTHOPROC)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble );
+    typedef void (CODEGEN_FUNCPTR *PFNCOLOR3DPROC)(GLdouble , GLdouble , GLdouble );
+
+    //////////////////////////////////////////////
+    // Function pointers
+
+    // Extension: 1.1
+    PFNCULLFACEPROC CullFace;
+    PFNFRONTFACEPROC FrontFace;
+    PFNHINTPROC Hint;
+    PFNLINEWIDTHPROC LineWidth;
+    PFNPOINTSIZEPROC PointSize;
+    PFNPOLYGONMODEPROC PolygonMode;
+    PFNSCISSORPROC Scissor;
+    PFNTEXPARAMETERFPROC TexParameterf;
+    PFNTEXPARAMETERFVPROC TexParameterfv;
+    PFNTEXPARAMETERIPROC TexParameteri;
+    PFNTEXPARAMETERIVPROC TexParameteriv;
+    PFNTEXIMAGE1DPROC TexImage1D;
+    PFNTEXIMAGE2DPROC TexImage2D;
+    PFNDRAWBUFFERPROC DrawBuffer;
+    PFNCLEARPROC Clear;
+    PFNCLEARCOLORPROC ClearColor;
+    PFNCLEARSTENCILPROC ClearStencil;
+    PFNCLEARDEPTHPROC ClearDepth;
+    PFNSTENCILMASKPROC StencilMask;
+    PFNCOLORMASKPROC ColorMask;
+    PFNDEPTHMASKPROC DepthMask;
+    PFNDISABLEPROC Disable;
+    PFNENABLEPROC Enable;
+    PFNFINISHPROC Finish;
+    PFNFLUSHPROC Flush;
+    PFNBLENDFUNCPROC BlendFunc;
+    PFNLOGICOPPROC LogicOp;
+    PFNSTENCILFUNCPROC StencilFunc;
+    PFNSTENCILOPPROC StencilOp;
+    PFNDEPTHFUNCPROC DepthFunc;
+    PFNPIXELSTOREFPROC PixelStoref;
+    PFNPIXELSTOREIPROC PixelStorei;
+    PFNREADBUFFERPROC ReadBuffer;
+    PFNREADPIXELSPROC ReadPixels;
+    PFNGETBOOLEANVPROC GetBooleanv;
+    PFNGETDOUBLEVPROC GetDoublev;
+    PFNGETERRORPROC GetError;
+    PFNGETFLOATVPROC GetFloatv;
+    PFNGETINTEGERVPROC GetIntegerv;
+    PFNGETSTRINGPROC GetString;
+    PFNGETTEXIMAGEPROC GetTexImage;
+    PFNGETTEXPARAMETERFVPROC GetTexParameterfv;
+    PFNGETTEXPARAMETERIVPROC GetTexParameteriv;
+    PFNGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv;
+    PFNGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv;
+    PFNISENABLEDPROC IsEnabled;
+    PFNDEPTHRANGEPROC DepthRange;
+    PFNVIEWPORTPROC Viewport;
+    PFNDRAWARRAYSPROC DrawArrays;
+    PFNDRAWELEMENTSPROC DrawElements;
+    PFNGETPOINTERVPROC GetPointerv;
+    PFNPOLYGONOFFSETPROC PolygonOffset;
+    PFNCOPYTEXIMAGE1DPROC CopyTexImage1D;
+    PFNCOPYTEXIMAGE2DPROC CopyTexImage2D;
+    PFNCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D;
+    PFNCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D;
+    PFNTEXSUBIMAGE1DPROC TexSubImage1D;
+    PFNTEXSUBIMAGE2DPROC TexSubImage2D;
+    PFNBINDTEXTUREPROC BindTexture;
+    PFNDELETETEXTURESPROC DeleteTextures;
+    PFNGENTEXTURESPROC GenTextures;
+    PFNISTEXTUREPROC IsTexture;
+    PFNINDEXUBPROC Indexub;
+    PFNINDEXUBVPROC Indexubv;
+
+    // Extension: 1.2
+    PFNBLENDCOLORPROC BlendColor;
+    PFNBLENDEQUATIONPROC BlendEquation;
+    PFNDRAWRANGEELEMENTSPROC DrawRangeElements;
+    PFNTEXSUBIMAGE3DPROC TexSubImage3D;
+    PFNCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D;
+
+    // Extension: 1.3
+    PFNACTIVETEXTUREPROC ActiveTexture;
+    PFNSAMPLECOVERAGEPROC SampleCoverage;
+    PFNCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D;
+    PFNCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D;
+    PFNCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D;
+    PFNCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D;
+    PFNCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D;
+    PFNCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D;
+    PFNGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage;
+
+    // Extension: 1.4
+    PFNBLENDFUNCSEPARATEPROC BlendFuncSeparate;
+    PFNMULTIDRAWARRAYSPROC MultiDrawArrays;
+    PFNMULTIDRAWELEMENTSPROC MultiDrawElements;
+    PFNPOINTPARAMETERFPROC PointParameterf;
+    PFNPOINTPARAMETERFVPROC PointParameterfv;
+    PFNPOINTPARAMETERIPROC PointParameteri;
+    PFNPOINTPARAMETERIVPROC PointParameteriv;
+
+    // Extension: 1.5
+    PFNGENQUERIESPROC GenQueries;
+    PFNDELETEQUERIESPROC DeleteQueries;
+    PFNISQUERYPROC IsQuery;
+    PFNBEGINQUERYPROC BeginQuery;
+    PFNENDQUERYPROC EndQuery;
+    PFNGETQUERYIVPROC GetQueryiv;
+    PFNGETQUERYOBJECTIVPROC GetQueryObjectiv;
+    PFNGETQUERYOBJECTUIVPROC GetQueryObjectuiv;
+    PFNBINDBUFFERPROC BindBuffer;
+    PFNDELETEBUFFERSPROC DeleteBuffers;
+    PFNGENBUFFERSPROC GenBuffers;
+    PFNISBUFFERPROC IsBuffer;
+    PFNBUFFERDATAPROC BufferData;
+    PFNBUFFERSUBDATAPROC BufferSubData;
+    PFNGETBUFFERSUBDATAPROC GetBufferSubData;
+    PFNMAPBUFFERPROC MapBuffer;
+    PFNUNMAPBUFFERPROC UnmapBuffer;
+    PFNGETBUFFERPARAMETERIVPROC GetBufferParameteriv;
+    PFNGETBUFFERPOINTERVPROC GetBufferPointerv;
+
+    // Extension: 2.0
+    PFNBLENDEQUATIONSEPARATEPROC BlendEquationSeparate;
+    PFNDRAWBUFFERSPROC DrawBuffers;
+    PFNSTENCILOPSEPARATEPROC StencilOpSeparate;
+    PFNSTENCILFUNCSEPARATEPROC StencilFuncSeparate;
+    PFNSTENCILMASKSEPARATEPROC StencilMaskSeparate;
+    PFNATTACHSHADERPROC AttachShader;
+    PFNBINDATTRIBLOCATIONPROC BindAttribLocation;
+    PFNCOMPILESHADERPROC CompileShader;
+    PFNCREATEPROGRAMPROC CreateProgram;
+    PFNCREATESHADERPROC CreateShader;
+    PFNDELETEPROGRAMPROC DeleteProgram;
+    PFNDELETESHADERPROC DeleteShader;
+    PFNDETACHSHADERPROC DetachShader;
+    PFNDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
+    PFNENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray;
+    PFNGETACTIVEATTRIBPROC GetActiveAttrib;
+    PFNGETACTIVEUNIFORMPROC GetActiveUniform;
+    PFNGETATTACHEDSHADERSPROC GetAttachedShaders;
+    PFNGETATTRIBLOCATIONPROC GetAttribLocation;
+    PFNGETPROGRAMIVPROC GetProgramiv;
+    PFNGETPROGRAMINFOLOGPROC GetProgramInfoLog;
+    PFNGETSHADERIVPROC GetShaderiv;
+    PFNGETSHADERINFOLOGPROC GetShaderInfoLog;
+    PFNGETSHADERSOURCEPROC GetShaderSource;
+    PFNGETUNIFORMLOCATIONPROC GetUniformLocation;
+    PFNGETUNIFORMFVPROC GetUniformfv;
+    PFNGETUNIFORMIVPROC GetUniformiv;
+    PFNGETVERTEXATTRIBDVPROC GetVertexAttribdv;
+    PFNGETVERTEXATTRIBFVPROC GetVertexAttribfv;
+    PFNGETVERTEXATTRIBIVPROC GetVertexAttribiv;
+    PFNGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv;
+    PFNISPROGRAMPROC IsProgram;
+    PFNISSHADERPROC IsShader;
+    PFNLINKPROGRAMPROC LinkProgram;
+    PFNSHADERSOURCEPROC ShaderSource;
+    PFNUSEPROGRAMPROC UseProgram;
+    PFNUNIFORM1FPROC Uniform1f;
+    PFNUNIFORM2FPROC Uniform2f;
+    PFNUNIFORM3FPROC Uniform3f;
+    PFNUNIFORM4FPROC Uniform4f;
+    PFNUNIFORM1IPROC Uniform1i;
+    PFNUNIFORM2IPROC Uniform2i;
+    PFNUNIFORM3IPROC Uniform3i;
+    PFNUNIFORM4IPROC Uniform4i;
+    PFNUNIFORM1FVPROC Uniform1fv;
+    PFNUNIFORM2FVPROC Uniform2fv;
+    PFNUNIFORM3FVPROC Uniform3fv;
+    PFNUNIFORM4FVPROC Uniform4fv;
+    PFNUNIFORM1IVPROC Uniform1iv;
+    PFNUNIFORM2IVPROC Uniform2iv;
+    PFNUNIFORM3IVPROC Uniform3iv;
+    PFNUNIFORM4IVPROC Uniform4iv;
+    PFNUNIFORMMATRIX2FVPROC UniformMatrix2fv;
+    PFNUNIFORMMATRIX3FVPROC UniformMatrix3fv;
+    PFNUNIFORMMATRIX4FVPROC UniformMatrix4fv;
+    PFNVALIDATEPROGRAMPROC ValidateProgram;
+    PFNVERTEXATTRIBPOINTERPROC VertexAttribPointer;
+
+    // Extension: 2.1
+    PFNUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv;
+    PFNUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv;
+    PFNUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv;
+    PFNUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv;
+    PFNUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv;
+    PFNUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv;
+
+    // Extension: ARB_vertex_array_object
+    PFNBINDVERTEXARRAYPROC BindVertexArray;
+    PFNDELETEVERTEXARRAYSPROC DeleteVertexArrays;
+    PFNGENVERTEXARRAYSPROC GenVertexArrays;
+    PFNISVERTEXARRAYPROC IsVertexArray;
+
+    // Extension: ARB_map_buffer_range
+    PFNMAPBUFFERRANGEPROC MapBufferRange;
+    PFNFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange;
+
+    // Extension: ARB_framebuffer_object
+    PFNISRENDERBUFFERPROC IsRenderbuffer;
+    PFNBINDRENDERBUFFERPROC BindRenderbuffer;
+    PFNDELETERENDERBUFFERSPROC DeleteRenderbuffers;
+    PFNGENRENDERBUFFERSPROC GenRenderbuffers;
+    PFNRENDERBUFFERSTORAGEPROC RenderbufferStorage;
+    PFNGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv;
+    PFNISFRAMEBUFFERPROC IsFramebuffer;
+    PFNBINDFRAMEBUFFERPROC BindFramebuffer;
+    PFNDELETEFRAMEBUFFERSPROC DeleteFramebuffers;
+    PFNGENFRAMEBUFFERSPROC GenFramebuffers;
+    PFNCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus;
+    PFNFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D;
+    PFNFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D;
+    PFNFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D;
+    PFNFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer;
+    PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv;
+    PFNGENERATEMIPMAPPROC GenerateMipmap;
+    PFNBLITFRAMEBUFFERPROC BlitFramebuffer;
+    PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample;
+    PFNFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer;
+
+    // Extension: 3.0
+    PFNCOLORMASKIPROC ColorMaski;
+    PFNGETBOOLEANI_VPROC GetBooleani_v;
+    PFNGETINTEGERI_VPROC GetIntegeri_v;
+    PFNENABLEIPROC Enablei;
+    PFNDISABLEIPROC Disablei;
+    PFNISENABLEDIPROC IsEnabledi;
+    PFNBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback;
+    PFNENDTRANSFORMFEEDBACKPROC EndTransformFeedback;
+    PFNBINDBUFFERRANGEPROC BindBufferRange;
+    PFNBINDBUFFERBASEPROC BindBufferBase;
+    PFNTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings;
+    PFNGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying;
+    PFNCLAMPCOLORPROC ClampColor;
+    PFNBEGINCONDITIONALRENDERPROC BeginConditionalRender;
+    PFNENDCONDITIONALRENDERPROC EndConditionalRender;
+    PFNVERTEXATTRIBIPOINTERPROC VertexAttribIPointer;
+    PFNGETVERTEXATTRIBIIVPROC GetVertexAttribIiv;
+    PFNGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv;
+    PFNVERTEXATTRIBI1IPROC VertexAttribI1i;
+    PFNVERTEXATTRIBI2IPROC VertexAttribI2i;
+    PFNVERTEXATTRIBI3IPROC VertexAttribI3i;
+    PFNVERTEXATTRIBI4IPROC VertexAttribI4i;
+    PFNVERTEXATTRIBI1UIPROC VertexAttribI1ui;
+    PFNVERTEXATTRIBI2UIPROC VertexAttribI2ui;
+    PFNVERTEXATTRIBI3UIPROC VertexAttribI3ui;
+    PFNVERTEXATTRIBI4UIPROC VertexAttribI4ui;
+    PFNVERTEXATTRIBI1IVPROC VertexAttribI1iv;
+    PFNVERTEXATTRIBI2IVPROC VertexAttribI2iv;
+    PFNVERTEXATTRIBI3IVPROC VertexAttribI3iv;
+    PFNVERTEXATTRIBI4IVPROC VertexAttribI4iv;
+    PFNVERTEXATTRIBI1UIVPROC VertexAttribI1uiv;
+    PFNVERTEXATTRIBI2UIVPROC VertexAttribI2uiv;
+    PFNVERTEXATTRIBI3UIVPROC VertexAttribI3uiv;
+    PFNVERTEXATTRIBI4UIVPROC VertexAttribI4uiv;
+    PFNVERTEXATTRIBI4BVPROC VertexAttribI4bv;
+    PFNVERTEXATTRIBI4SVPROC VertexAttribI4sv;
+    PFNVERTEXATTRIBI4UBVPROC VertexAttribI4ubv;
+    PFNVERTEXATTRIBI4USVPROC VertexAttribI4usv;
+    PFNGETUNIFORMUIVPROC GetUniformuiv;
+    PFNBINDFRAGDATALOCATIONPROC BindFragDataLocation;
+    PFNGETFRAGDATALOCATIONPROC GetFragDataLocation;
+    PFNUNIFORM1UIPROC Uniform1ui;
+    PFNUNIFORM2UIPROC Uniform2ui;
+    PFNUNIFORM3UIPROC Uniform3ui;
+    PFNUNIFORM4UIPROC Uniform4ui;
+    PFNUNIFORM1UIVPROC Uniform1uiv;
+    PFNUNIFORM2UIVPROC Uniform2uiv;
+    PFNUNIFORM3UIVPROC Uniform3uiv;
+    PFNUNIFORM4UIVPROC Uniform4uiv;
+    PFNTEXPARAMETERIIVPROC TexParameterIiv;
+    PFNTEXPARAMETERIUIVPROC TexParameterIuiv;
+    PFNGETTEXPARAMETERIIVPROC GetTexParameterIiv;
+    PFNGETTEXPARAMETERIUIVPROC GetTexParameterIuiv;
+    PFNCLEARBUFFERIVPROC ClearBufferiv;
+    PFNCLEARBUFFERUIVPROC ClearBufferuiv;
+    PFNCLEARBUFFERFVPROC ClearBufferfv;
+    PFNCLEARBUFFERFIPROC ClearBufferfi;
+    PFNGETSTRINGIPROC GetStringi;
+
+    // Extension: ARB_uniform_buffer_object
+    PFNGETUNIFORMINDICESPROC GetUniformIndices;
+    PFNGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv;
+    PFNGETACTIVEUNIFORMNAMEPROC GetActiveUniformName;
+    PFNGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex;
+    PFNGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv;
+    PFNGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName;
+    PFNUNIFORMBLOCKBINDINGPROC UniformBlockBinding;
+
+    // Extension: ARB_copy_buffer
+    PFNCOPYBUFFERSUBDATAPROC CopyBufferSubData;
+
+    // Extension: 3.1
+    PFNDRAWARRAYSINSTANCEDPROC DrawArraysInstanced;
+    PFNDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced;
+    PFNTEXBUFFERPROC TexBuffer;
+    PFNPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex;
+
+    // Legacy
+    PFNENABLECLIENTSTATEPROC EnableClientState;
+    PFNDISABLECLIENTSTATEPROC DisableClientState;
+    PFNVERTEXPOINTERPROC VertexPointer;
+    PFNNORMALPOINTERPROC NormalPointer;
+    PFNCOLORPOINTERPROC ColorPointer;
+    PFNTEXCOORDPOINTERPROC TexCoordPointer;
+
+    PFNTEXENVIPROC TexEnvi;
+
+    PFNMATRIXMODEPROC MatrixMode;
+    PFNLOADIDENTITYPROC LoadIdentity;
+    PFNORTHOPROC Ortho;
+
+    PFNCOLOR3DPROC Color3d;
+
+    //////////////////////////////////////////////
+    // Switch functions
+
+    // Extension: 1.1
+
+    static void CODEGEN_FUNCPTR Switch_CullFace(GLenum mode)
+    {
+        CullFace = (PFNCULLFACEPROC)IntGetProcAddress("glCullFace");
+        CullFace(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FrontFace(GLenum mode)
+    {
+        FrontFace = (PFNFRONTFACEPROC)IntGetProcAddress("glFrontFace");
+        FrontFace(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Hint(GLenum target, GLenum mode)
+    {
+        Hint = (PFNHINTPROC)IntGetProcAddress("glHint");
+        Hint(target, mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_LineWidth(GLfloat width)
+    {
+        LineWidth = (PFNLINEWIDTHPROC)IntGetProcAddress("glLineWidth");
+        LineWidth(width);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PointSize(GLfloat size)
+    {
+        PointSize = (PFNPOINTSIZEPROC)IntGetProcAddress("glPointSize");
+        PointSize(size);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PolygonMode(GLenum face, GLenum mode)
+    {
+        PolygonMode = (PFNPOLYGONMODEPROC)IntGetProcAddress("glPolygonMode");
+        PolygonMode(face, mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+    {
+        Scissor = (PFNSCISSORPROC)IntGetProcAddress("glScissor");
+        Scissor(x, y, width, height);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameterf(GLenum target, GLenum pname, GLfloat param)
+    {
+        TexParameterf = (PFNTEXPARAMETERFPROC)IntGetProcAddress("glTexParameterf");
+        TexParameterf(target, pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
+    {
+        TexParameterfv = (PFNTEXPARAMETERFVPROC)IntGetProcAddress("glTexParameterfv");
+        TexParameterfv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameteri(GLenum target, GLenum pname, GLint param)
+    {
+        TexParameteri = (PFNTEXPARAMETERIPROC)IntGetProcAddress("glTexParameteri");
+        TexParameteri(target, pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
+    {
+        TexParameteriv = (PFNTEXPARAMETERIVPROC)IntGetProcAddress("glTexParameteriv");
+        TexParameteriv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+    {
+        TexImage1D = (PFNTEXIMAGE1DPROC)IntGetProcAddress("glTexImage1D");
+        TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
+    {
+        TexImage2D = (PFNTEXIMAGE2DPROC)IntGetProcAddress("glTexImage2D");
+        TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawBuffer(GLenum mode)
+    {
+        DrawBuffer = (PFNDRAWBUFFERPROC)IntGetProcAddress("glDrawBuffer");
+        DrawBuffer(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Clear(GLbitfield mask)
+    {
+        Clear = (PFNCLEARPROC)IntGetProcAddress("glClear");
+        Clear(mask);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+    {
+        ClearColor = (PFNCLEARCOLORPROC)IntGetProcAddress("glClearColor");
+        ClearColor(red, green, blue, alpha);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearStencil(GLint s)
+    {
+        ClearStencil = (PFNCLEARSTENCILPROC)IntGetProcAddress("glClearStencil");
+        ClearStencil(s);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearDepth(GLdouble depth)
+    {
+        ClearDepth = (PFNCLEARDEPTHPROC)IntGetProcAddress("glClearDepth");
+        ClearDepth(depth);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilMask(GLuint mask)
+    {
+        StencilMask = (PFNSTENCILMASKPROC)IntGetProcAddress("glStencilMask");
+        StencilMask(mask);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+    {
+        ColorMask = (PFNCOLORMASKPROC)IntGetProcAddress("glColorMask");
+        ColorMask(red, green, blue, alpha);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DepthMask(GLboolean flag)
+    {
+        DepthMask = (PFNDEPTHMASKPROC)IntGetProcAddress("glDepthMask");
+        DepthMask(flag);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Disable(GLenum cap)
+    {
+        Disable = (PFNDISABLEPROC)IntGetProcAddress("glDisable");
+        Disable(cap);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Enable(GLenum cap)
+    {
+        Enable = (PFNENABLEPROC)IntGetProcAddress("glEnable");
+        Enable(cap);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Finish()
+    {
+        Finish = (PFNFINISHPROC)IntGetProcAddress("glFinish");
+        Finish();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Flush()
+    {
+        Flush = (PFNFLUSHPROC)IntGetProcAddress("glFlush");
+        Flush();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BlendFunc(GLenum sfactor, GLenum dfactor)
+    {
+        BlendFunc = (PFNBLENDFUNCPROC)IntGetProcAddress("glBlendFunc");
+        BlendFunc(sfactor, dfactor);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_LogicOp(GLenum opcode)
+    {
+        LogicOp = (PFNLOGICOPPROC)IntGetProcAddress("glLogicOp");
+        LogicOp(opcode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilFunc(GLenum func, GLint ref, GLuint mask)
+    {
+        StencilFunc = (PFNSTENCILFUNCPROC)IntGetProcAddress("glStencilFunc");
+        StencilFunc(func, ref, mask);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+    {
+        StencilOp = (PFNSTENCILOPPROC)IntGetProcAddress("glStencilOp");
+        StencilOp(fail, zfail, zpass);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DepthFunc(GLenum func)
+    {
+        DepthFunc = (PFNDEPTHFUNCPROC)IntGetProcAddress("glDepthFunc");
+        DepthFunc(func);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PixelStoref(GLenum pname, GLfloat param)
+    {
+        PixelStoref = (PFNPIXELSTOREFPROC)IntGetProcAddress("glPixelStoref");
+        PixelStoref(pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PixelStorei(GLenum pname, GLint param)
+    {
+        PixelStorei = (PFNPIXELSTOREIPROC)IntGetProcAddress("glPixelStorei");
+        PixelStorei(pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ReadBuffer(GLenum mode)
+    {
+        ReadBuffer = (PFNREADBUFFERPROC)IntGetProcAddress("glReadBuffer");
+        ReadBuffer(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
+    {
+        ReadPixels = (PFNREADPIXELSPROC)IntGetProcAddress("glReadPixels");
+        ReadPixels(x, y, width, height, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetBooleanv(GLenum pname, GLboolean *params)
+    {
+        GetBooleanv = (PFNGETBOOLEANVPROC)IntGetProcAddress("glGetBooleanv");
+        GetBooleanv(pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetDoublev(GLenum pname, GLdouble *params)
+    {
+        GetDoublev = (PFNGETDOUBLEVPROC)IntGetProcAddress("glGetDoublev");
+        GetDoublev(pname, params);
+    }
+
+    static GLenum CODEGEN_FUNCPTR Switch_GetError()
+    {
+        GetError = (PFNGETERRORPROC)IntGetProcAddress("glGetError");
+        return GetError();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetFloatv(GLenum pname, GLfloat *params)
+    {
+        GetFloatv = (PFNGETFLOATVPROC)IntGetProcAddress("glGetFloatv");
+        GetFloatv(pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetIntegerv(GLenum pname, GLint *params)
+    {
+        GetIntegerv = (PFNGETINTEGERVPROC)IntGetProcAddress("glGetIntegerv");
+        GetIntegerv(pname, params);
+    }
+
+    static const GLubyte * CODEGEN_FUNCPTR Switch_GetString(GLenum name)
+    {
+        GetString = (PFNGETSTRINGPROC)IntGetProcAddress("glGetString");
+        return GetString(name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
+    {
+        GetTexImage = (PFNGETTEXIMAGEPROC)IntGetProcAddress("glGetTexImage");
+        GetTexImage(target, level, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
+    {
+        GetTexParameterfv = (PFNGETTEXPARAMETERFVPROC)IntGetProcAddress("glGetTexParameterfv");
+        GetTexParameterfv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
+    {
+        GetTexParameteriv = (PFNGETTEXPARAMETERIVPROC)IntGetProcAddress("glGetTexParameteriv");
+        GetTexParameteriv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+    {
+        GetTexLevelParameterfv = (PFNGETTEXLEVELPARAMETERFVPROC)IntGetProcAddress("glGetTexLevelParameterfv");
+        GetTexLevelParameterfv(target, level, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+    {
+        GetTexLevelParameteriv = (PFNGETTEXLEVELPARAMETERIVPROC)IntGetProcAddress("glGetTexLevelParameteriv");
+        GetTexLevelParameteriv(target, level, pname, params);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsEnabled(GLenum cap)
+    {
+        IsEnabled = (PFNISENABLEDPROC)IntGetProcAddress("glIsEnabled");
+        return IsEnabled(cap);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DepthRange(GLdouble ren_near, GLdouble ren_far)
+    {
+        DepthRange = (PFNDEPTHRANGEPROC)IntGetProcAddress("glDepthRange");
+        DepthRange(ren_near, ren_far);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+    {
+        Viewport = (PFNVIEWPORTPROC)IntGetProcAddress("glViewport");
+        Viewport(x, y, width, height);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawArrays(GLenum mode, GLint first, GLsizei count)
+    {
+        DrawArrays = (PFNDRAWARRAYSPROC)IntGetProcAddress("glDrawArrays");
+        DrawArrays(mode, first, count);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+    {
+        DrawElements = (PFNDRAWELEMENTSPROC)IntGetProcAddress("glDrawElements");
+        DrawElements(mode, count, type, indices);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetPointerv(GLenum pname, GLvoid* *params)
+    {
+        GetPointerv = (PFNGETPOINTERVPROC)IntGetProcAddress("glGetPointerv");
+        GetPointerv(pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PolygonOffset(GLfloat factor, GLfloat units)
+    {
+        PolygonOffset = (PFNPOLYGONOFFSETPROC)IntGetProcAddress("glPolygonOffset");
+        PolygonOffset(factor, units);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+    {
+        CopyTexImage1D = (PFNCOPYTEXIMAGE1DPROC)IntGetProcAddress("glCopyTexImage1D");
+        CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+    {
+        CopyTexImage2D = (PFNCOPYTEXIMAGE2DPROC)IntGetProcAddress("glCopyTexImage2D");
+        CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+    {
+        CopyTexSubImage1D = (PFNCOPYTEXSUBIMAGE1DPROC)IntGetProcAddress("glCopyTexSubImage1D");
+        CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+    {
+        CopyTexSubImage2D = (PFNCOPYTEXSUBIMAGE2DPROC)IntGetProcAddress("glCopyTexSubImage2D");
+        CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
+    {
+        TexSubImage1D = (PFNTEXSUBIMAGE1DPROC)IntGetProcAddress("glTexSubImage1D");
+        TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
+    {
+        TexSubImage2D = (PFNTEXSUBIMAGE2DPROC)IntGetProcAddress("glTexSubImage2D");
+        TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindTexture(GLenum target, GLuint texture)
+    {
+        BindTexture = (PFNBINDTEXTUREPROC)IntGetProcAddress("glBindTexture");
+        BindTexture(target, texture);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteTextures(GLsizei n, const GLuint *textures)
+    {
+        DeleteTextures = (PFNDELETETEXTURESPROC)IntGetProcAddress("glDeleteTextures");
+        DeleteTextures(n, textures);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenTextures(GLsizei n, GLuint *textures)
+    {
+        GenTextures = (PFNGENTEXTURESPROC)IntGetProcAddress("glGenTextures");
+        GenTextures(n, textures);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsTexture(GLuint texture)
+    {
+        IsTexture = (PFNISTEXTUREPROC)IntGetProcAddress("glIsTexture");
+        return IsTexture(texture);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Indexub(GLubyte c)
+    {
+        Indexub = (PFNINDEXUBPROC)IntGetProcAddress("glIndexub");
+        Indexub(c);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Indexubv(const GLubyte *c)
+    {
+        Indexubv = (PFNINDEXUBVPROC)IntGetProcAddress("glIndexubv");
+        Indexubv(c);
+    }
+
+    // Extension: 1.2
+
+    static void CODEGEN_FUNCPTR Switch_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+    {
+        BlendColor = (PFNBLENDCOLORPROC)IntGetProcAddress("glBlendColor");
+        BlendColor(red, green, blue, alpha);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BlendEquation(GLenum mode)
+    {
+        BlendEquation = (PFNBLENDEQUATIONPROC)IntGetProcAddress("glBlendEquation");
+        BlendEquation(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
+    {
+        DrawRangeElements = (PFNDRAWRANGEELEMENTSPROC)IntGetProcAddress("glDrawRangeElements");
+        DrawRangeElements(mode, start, end, count, type, indices);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
+    {
+        TexSubImage3D = (PFNTEXSUBIMAGE3DPROC)IntGetProcAddress("glTexSubImage3D");
+        TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+    {
+        CopyTexSubImage3D = (PFNCOPYTEXSUBIMAGE3DPROC)IntGetProcAddress("glCopyTexSubImage3D");
+        CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    }
+
+    // Extension: 1.3
+
+    static void CODEGEN_FUNCPTR Switch_ActiveTexture(GLenum texture)
+    {
+        ActiveTexture = (PFNACTIVETEXTUREPROC)IntGetProcAddress("glActiveTexture");
+        ActiveTexture(texture);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_SampleCoverage(GLfloat value, GLboolean invert)
+    {
+        SampleCoverage = (PFNSAMPLECOVERAGEPROC)IntGetProcAddress("glSampleCoverage");
+        SampleCoverage(value, invert);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexImage3D = (PFNCOMPRESSEDTEXIMAGE3DPROC)IntGetProcAddress("glCompressedTexImage3D");
+        CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexImage2D = (PFNCOMPRESSEDTEXIMAGE2DPROC)IntGetProcAddress("glCompressedTexImage2D");
+        CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexImage1D = (PFNCOMPRESSEDTEXIMAGE1DPROC)IntGetProcAddress("glCompressedTexImage1D");
+        CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexSubImage3D = (PFNCOMPRESSEDTEXSUBIMAGE3DPROC)IntGetProcAddress("glCompressedTexSubImage3D");
+        CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexSubImage2D = (PFNCOMPRESSEDTEXSUBIMAGE2DPROC)IntGetProcAddress("glCompressedTexSubImage2D");
+        CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
+    {
+        CompressedTexSubImage1D = (PFNCOMPRESSEDTEXSUBIMAGE1DPROC)IntGetProcAddress("glCompressedTexSubImage1D");
+        CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
+    {
+        GetCompressedTexImage = (PFNGETCOMPRESSEDTEXIMAGEPROC)IntGetProcAddress("glGetCompressedTexImage");
+        GetCompressedTexImage(target, level, img);
+    }
+
+    // Extension: 1.4
+
+    static void CODEGEN_FUNCPTR Switch_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+    {
+        BlendFuncSeparate = (PFNBLENDFUNCSEPARATEPROC)IntGetProcAddress("glBlendFuncSeparate");
+        BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_MultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
+    {
+        MultiDrawArrays = (PFNMULTIDRAWARRAYSPROC)IntGetProcAddress("glMultiDrawArrays");
+        MultiDrawArrays(mode, first, count, drawcount);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
+    {
+        MultiDrawElements = (PFNMULTIDRAWELEMENTSPROC)IntGetProcAddress("glMultiDrawElements");
+        MultiDrawElements(mode, count, type, indices, drawcount);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PointParameterf(GLenum pname, GLfloat param)
+    {
+        PointParameterf = (PFNPOINTPARAMETERFPROC)IntGetProcAddress("glPointParameterf");
+        PointParameterf(pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PointParameterfv(GLenum pname, const GLfloat *params)
+    {
+        PointParameterfv = (PFNPOINTPARAMETERFVPROC)IntGetProcAddress("glPointParameterfv");
+        PointParameterfv(pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PointParameteri(GLenum pname, GLint param)
+    {
+        PointParameteri = (PFNPOINTPARAMETERIPROC)IntGetProcAddress("glPointParameteri");
+        PointParameteri(pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PointParameteriv(GLenum pname, const GLint *params)
+    {
+        PointParameteriv = (PFNPOINTPARAMETERIVPROC)IntGetProcAddress("glPointParameteriv");
+        PointParameteriv(pname, params);
+    }
+
+    // Extension: 1.5
+
+    static void CODEGEN_FUNCPTR Switch_GenQueries(GLsizei n, GLuint *ids)
+    {
+        GenQueries = (PFNGENQUERIESPROC)IntGetProcAddress("glGenQueries");
+        GenQueries(n, ids);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteQueries(GLsizei n, const GLuint *ids)
+    {
+        DeleteQueries = (PFNDELETEQUERIESPROC)IntGetProcAddress("glDeleteQueries");
+        DeleteQueries(n, ids);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsQuery(GLuint id)
+    {
+        IsQuery = (PFNISQUERYPROC)IntGetProcAddress("glIsQuery");
+        return IsQuery(id);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BeginQuery(GLenum target, GLuint id)
+    {
+        BeginQuery = (PFNBEGINQUERYPROC)IntGetProcAddress("glBeginQuery");
+        BeginQuery(target, id);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_EndQuery(GLenum target)
+    {
+        EndQuery = (PFNENDQUERYPROC)IntGetProcAddress("glEndQuery");
+        EndQuery(target);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetQueryiv(GLenum target, GLenum pname, GLint *params)
+    {
+        GetQueryiv = (PFNGETQUERYIVPROC)IntGetProcAddress("glGetQueryiv");
+        GetQueryiv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
+    {
+        GetQueryObjectiv = (PFNGETQUERYOBJECTIVPROC)IntGetProcAddress("glGetQueryObjectiv");
+        GetQueryObjectiv(id, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
+    {
+        GetQueryObjectuiv = (PFNGETQUERYOBJECTUIVPROC)IntGetProcAddress("glGetQueryObjectuiv");
+        GetQueryObjectuiv(id, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindBuffer(GLenum target, GLuint buffer)
+    {
+        BindBuffer = (PFNBINDBUFFERPROC)IntGetProcAddress("glBindBuffer");
+        BindBuffer(target, buffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteBuffers(GLsizei n, const GLuint *buffers)
+    {
+        DeleteBuffers = (PFNDELETEBUFFERSPROC)IntGetProcAddress("glDeleteBuffers");
+        DeleteBuffers(n, buffers);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenBuffers(GLsizei n, GLuint *buffers)
+    {
+        GenBuffers = (PFNGENBUFFERSPROC)IntGetProcAddress("glGenBuffers");
+        GenBuffers(n, buffers);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsBuffer(GLuint buffer)
+    {
+        IsBuffer = (PFNISBUFFERPROC)IntGetProcAddress("glIsBuffer");
+        return IsBuffer(buffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
+    {
+        BufferData = (PFNBUFFERDATAPROC)IntGetProcAddress("glBufferData");
+        BufferData(target, size, data, usage);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
+    {
+        BufferSubData = (PFNBUFFERSUBDATAPROC)IntGetProcAddress("glBufferSubData");
+        BufferSubData(target, offset, size, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
+    {
+        GetBufferSubData = (PFNGETBUFFERSUBDATAPROC)IntGetProcAddress("glGetBufferSubData");
+        GetBufferSubData(target, offset, size, data);
+    }
+
+    static GLvoid* CODEGEN_FUNCPTR Switch_MapBuffer(GLenum target, GLenum access)
+    {
+        MapBuffer = (PFNMAPBUFFERPROC)IntGetProcAddress("glMapBuffer");
+        return MapBuffer(target, access);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_UnmapBuffer(GLenum target)
+    {
+        UnmapBuffer = (PFNUNMAPBUFFERPROC)IntGetProcAddress("glUnmapBuffer");
+        return UnmapBuffer(target);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
+    {
+        GetBufferParameteriv = (PFNGETBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetBufferParameteriv");
+        GetBufferParameteriv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
+    {
+        GetBufferPointerv = (PFNGETBUFFERPOINTERVPROC)IntGetProcAddress("glGetBufferPointerv");
+        GetBufferPointerv(target, pname, params);
+    }
+
+    // Extension: 2.0
+
+    static void CODEGEN_FUNCPTR Switch_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
+    {
+        BlendEquationSeparate = (PFNBLENDEQUATIONSEPARATEPROC)IntGetProcAddress("glBlendEquationSeparate");
+        BlendEquationSeparate(modeRGB, modeAlpha);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawBuffers(GLsizei n, const GLenum *bufs)
+    {
+        DrawBuffers = (PFNDRAWBUFFERSPROC)IntGetProcAddress("glDrawBuffers");
+        DrawBuffers(n, bufs);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
+    {
+        StencilOpSeparate = (PFNSTENCILOPSEPARATEPROC)IntGetProcAddress("glStencilOpSeparate");
+        StencilOpSeparate(face, sfail, dpfail, dppass);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+    {
+        StencilFuncSeparate = (PFNSTENCILFUNCSEPARATEPROC)IntGetProcAddress("glStencilFuncSeparate");
+        StencilFuncSeparate(face, func, ref, mask);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_StencilMaskSeparate(GLenum face, GLuint mask)
+    {
+        StencilMaskSeparate = (PFNSTENCILMASKSEPARATEPROC)IntGetProcAddress("glStencilMaskSeparate");
+        StencilMaskSeparate(face, mask);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_AttachShader(GLuint program, GLuint shader)
+    {
+        AttachShader = (PFNATTACHSHADERPROC)IntGetProcAddress("glAttachShader");
+        AttachShader(program, shader);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
+    {
+        BindAttribLocation = (PFNBINDATTRIBLOCATIONPROC)IntGetProcAddress("glBindAttribLocation");
+        BindAttribLocation(program, index, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_CompileShader(GLuint shader)
+    {
+        CompileShader = (PFNCOMPILESHADERPROC)IntGetProcAddress("glCompileShader");
+        CompileShader(shader);
+    }
+
+    static GLuint CODEGEN_FUNCPTR Switch_CreateProgram()
+    {
+        CreateProgram = (PFNCREATEPROGRAMPROC)IntGetProcAddress("glCreateProgram");
+        return CreateProgram();
+    }
+
+    static GLuint CODEGEN_FUNCPTR Switch_CreateShader(GLenum type)
+    {
+        CreateShader = (PFNCREATESHADERPROC)IntGetProcAddress("glCreateShader");
+        return CreateShader(type);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteProgram(GLuint program)
+    {
+        DeleteProgram = (PFNDELETEPROGRAMPROC)IntGetProcAddress("glDeleteProgram");
+        DeleteProgram(program);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteShader(GLuint shader)
+    {
+        DeleteShader = (PFNDELETESHADERPROC)IntGetProcAddress("glDeleteShader");
+        DeleteShader(shader);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DetachShader(GLuint program, GLuint shader)
+    {
+        DetachShader = (PFNDETACHSHADERPROC)IntGetProcAddress("glDetachShader");
+        DetachShader(program, shader);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DisableVertexAttribArray(GLuint index)
+    {
+        DisableVertexAttribArray = (PFNDISABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glDisableVertexAttribArray");
+        DisableVertexAttribArray(index);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_EnableVertexAttribArray(GLuint index)
+    {
+        EnableVertexAttribArray = (PFNENABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glEnableVertexAttribArray");
+        EnableVertexAttribArray(index);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+    {
+        GetActiveAttrib = (PFNGETACTIVEATTRIBPROC)IntGetProcAddress("glGetActiveAttrib");
+        GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
+    {
+        GetActiveUniform = (PFNGETACTIVEUNIFORMPROC)IntGetProcAddress("glGetActiveUniform");
+        GetActiveUniform(program, index, bufSize, length, size, type, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
+    {
+        GetAttachedShaders = (PFNGETATTACHEDSHADERSPROC)IntGetProcAddress("glGetAttachedShaders");
+        GetAttachedShaders(program, maxCount, count, obj);
+    }
+
+    static GLint CODEGEN_FUNCPTR Switch_GetAttribLocation(GLuint program, const GLchar *name)
+    {
+        GetAttribLocation = (PFNGETATTRIBLOCATIONPROC)IntGetProcAddress("glGetAttribLocation");
+        return GetAttribLocation(program, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetProgramiv(GLuint program, GLenum pname, GLint *params)
+    {
+        GetProgramiv = (PFNGETPROGRAMIVPROC)IntGetProcAddress("glGetProgramiv");
+        GetProgramiv(program, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+    {
+        GetProgramInfoLog = (PFNGETPROGRAMINFOLOGPROC)IntGetProcAddress("glGetProgramInfoLog");
+        GetProgramInfoLog(program, bufSize, length, infoLog);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+    {
+        GetShaderiv = (PFNGETSHADERIVPROC)IntGetProcAddress("glGetShaderiv");
+        GetShaderiv(shader, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
+    {
+        GetShaderInfoLog = (PFNGETSHADERINFOLOGPROC)IntGetProcAddress("glGetShaderInfoLog");
+        GetShaderInfoLog(shader, bufSize, length, infoLog);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
+    {
+        GetShaderSource = (PFNGETSHADERSOURCEPROC)IntGetProcAddress("glGetShaderSource");
+        GetShaderSource(shader, bufSize, length, source);
+    }
+
+    static GLint CODEGEN_FUNCPTR Switch_GetUniformLocation(GLuint program, const GLchar *name)
+    {
+        GetUniformLocation = (PFNGETUNIFORMLOCATIONPROC)IntGetProcAddress("glGetUniformLocation");
+        return GetUniformLocation(program, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetUniformfv(GLuint program, GLint location, GLfloat *params)
+    {
+        GetUniformfv = (PFNGETUNIFORMFVPROC)IntGetProcAddress("glGetUniformfv");
+        GetUniformfv(program, location, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetUniformiv(GLuint program, GLint location, GLint *params)
+    {
+        GetUniformiv = (PFNGETUNIFORMIVPROC)IntGetProcAddress("glGetUniformiv");
+        GetUniformiv(program, location, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
+    {
+        GetVertexAttribdv = (PFNGETVERTEXATTRIBDVPROC)IntGetProcAddress("glGetVertexAttribdv");
+        GetVertexAttribdv(index, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
+    {
+        GetVertexAttribfv = (PFNGETVERTEXATTRIBFVPROC)IntGetProcAddress("glGetVertexAttribfv");
+        GetVertexAttribfv(index, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
+    {
+        GetVertexAttribiv = (PFNGETVERTEXATTRIBIVPROC)IntGetProcAddress("glGetVertexAttribiv");
+        GetVertexAttribiv(index, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
+    {
+        GetVertexAttribPointerv = (PFNGETVERTEXATTRIBPOINTERVPROC)IntGetProcAddress("glGetVertexAttribPointerv");
+        GetVertexAttribPointerv(index, pname, pointer);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsProgram(GLuint program)
+    {
+        IsProgram = (PFNISPROGRAMPROC)IntGetProcAddress("glIsProgram");
+        return IsProgram(program);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsShader(GLuint shader)
+    {
+        IsShader = (PFNISSHADERPROC)IntGetProcAddress("glIsShader");
+        return IsShader(shader);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_LinkProgram(GLuint program)
+    {
+        LinkProgram = (PFNLINKPROGRAMPROC)IntGetProcAddress("glLinkProgram");
+        LinkProgram(program);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
+    {
+        ShaderSource = (PFNSHADERSOURCEPROC)IntGetProcAddress("glShaderSource");
+        ShaderSource(shader, count, string, length);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UseProgram(GLuint program)
+    {
+        UseProgram = (PFNUSEPROGRAMPROC)IntGetProcAddress("glUseProgram");
+        UseProgram(program);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1f(GLint location, GLfloat v0)
+    {
+        Uniform1f = (PFNUNIFORM1FPROC)IntGetProcAddress("glUniform1f");
+        Uniform1f(location, v0);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
+    {
+        Uniform2f = (PFNUNIFORM2FPROC)IntGetProcAddress("glUniform2f");
+        Uniform2f(location, v0, v1);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+    {
+        Uniform3f = (PFNUNIFORM3FPROC)IntGetProcAddress("glUniform3f");
+        Uniform3f(location, v0, v1, v2);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+    {
+        Uniform4f = (PFNUNIFORM4FPROC)IntGetProcAddress("glUniform4f");
+        Uniform4f(location, v0, v1, v2, v3);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1i(GLint location, GLint v0)
+    {
+        Uniform1i = (PFNUNIFORM1IPROC)IntGetProcAddress("glUniform1i");
+        Uniform1i(location, v0);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2i(GLint location, GLint v0, GLint v1)
+    {
+        Uniform2i = (PFNUNIFORM2IPROC)IntGetProcAddress("glUniform2i");
+        Uniform2i(location, v0, v1);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
+    {
+        Uniform3i = (PFNUNIFORM3IPROC)IntGetProcAddress("glUniform3i");
+        Uniform3i(location, v0, v1, v2);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+    {
+        Uniform4i = (PFNUNIFORM4IPROC)IntGetProcAddress("glUniform4i");
+        Uniform4i(location, v0, v1, v2, v3);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
+    {
+        Uniform1fv = (PFNUNIFORM1FVPROC)IntGetProcAddress("glUniform1fv");
+        Uniform1fv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
+    {
+        Uniform2fv = (PFNUNIFORM2FVPROC)IntGetProcAddress("glUniform2fv");
+        Uniform2fv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
+    {
+        Uniform3fv = (PFNUNIFORM3FVPROC)IntGetProcAddress("glUniform3fv");
+        Uniform3fv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
+    {
+        Uniform4fv = (PFNUNIFORM4FVPROC)IntGetProcAddress("glUniform4fv");
+        Uniform4fv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1iv(GLint location, GLsizei count, const GLint *value)
+    {
+        Uniform1iv = (PFNUNIFORM1IVPROC)IntGetProcAddress("glUniform1iv");
+        Uniform1iv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2iv(GLint location, GLsizei count, const GLint *value)
+    {
+        Uniform2iv = (PFNUNIFORM2IVPROC)IntGetProcAddress("glUniform2iv");
+        Uniform2iv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3iv(GLint location, GLsizei count, const GLint *value)
+    {
+        Uniform3iv = (PFNUNIFORM3IVPROC)IntGetProcAddress("glUniform3iv");
+        Uniform3iv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4iv(GLint location, GLsizei count, const GLint *value)
+    {
+        Uniform4iv = (PFNUNIFORM4IVPROC)IntGetProcAddress("glUniform4iv");
+        Uniform4iv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix2fv = (PFNUNIFORMMATRIX2FVPROC)IntGetProcAddress("glUniformMatrix2fv");
+        UniformMatrix2fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix3fv = (PFNUNIFORMMATRIX3FVPROC)IntGetProcAddress("glUniformMatrix3fv");
+        UniformMatrix3fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix4fv = (PFNUNIFORMMATRIX4FVPROC)IntGetProcAddress("glUniformMatrix4fv");
+        UniformMatrix4fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ValidateProgram(GLuint program)
+    {
+        ValidateProgram = (PFNVALIDATEPROGRAMPROC)IntGetProcAddress("glValidateProgram");
+        ValidateProgram(program);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
+    {
+        VertexAttribPointer = (PFNVERTEXATTRIBPOINTERPROC)IntGetProcAddress("glVertexAttribPointer");
+        VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    }
+
+    // Extension: 2.1
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix2x3fv = (PFNUNIFORMMATRIX2X3FVPROC)IntGetProcAddress("glUniformMatrix2x3fv");
+        UniformMatrix2x3fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix3x2fv = (PFNUNIFORMMATRIX3X2FVPROC)IntGetProcAddress("glUniformMatrix3x2fv");
+        UniformMatrix3x2fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix2x4fv = (PFNUNIFORMMATRIX2X4FVPROC)IntGetProcAddress("glUniformMatrix2x4fv");
+        UniformMatrix2x4fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix4x2fv = (PFNUNIFORMMATRIX4X2FVPROC)IntGetProcAddress("glUniformMatrix4x2fv");
+        UniformMatrix4x2fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix3x4fv = (PFNUNIFORMMATRIX3X4FVPROC)IntGetProcAddress("glUniformMatrix3x4fv");
+        UniformMatrix3x4fv(location, count, transpose, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
+    {
+        UniformMatrix4x3fv = (PFNUNIFORMMATRIX4X3FVPROC)IntGetProcAddress("glUniformMatrix4x3fv");
+        UniformMatrix4x3fv(location, count, transpose, value);
+    }
+
+    // Extension: ARB_vertex_array_object
+
+    static void CODEGEN_FUNCPTR Switch_BindVertexArray(GLuint ren_array)
+    {
+        BindVertexArray = (PFNBINDVERTEXARRAYPROC)IntGetProcAddress("glBindVertexArray");
+        BindVertexArray(ren_array);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteVertexArrays(GLsizei n, const GLuint *arrays)
+    {
+        DeleteVertexArrays = (PFNDELETEVERTEXARRAYSPROC)IntGetProcAddress("glDeleteVertexArrays");
+        DeleteVertexArrays(n, arrays);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenVertexArrays(GLsizei n, GLuint *arrays)
+    {
+        GenVertexArrays = (PFNGENVERTEXARRAYSPROC)IntGetProcAddress("glGenVertexArrays");
+        GenVertexArrays(n, arrays);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsVertexArray(GLuint ren_array)
+    {
+        IsVertexArray = (PFNISVERTEXARRAYPROC)IntGetProcAddress("glIsVertexArray");
+        return IsVertexArray(ren_array);
+    }
+
+    // Extension: ARB_map_buffer_range
+
+    static GLvoid* CODEGEN_FUNCPTR Switch_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
+    {
+        MapBufferRange = (PFNMAPBUFFERRANGEPROC)IntGetProcAddress("glMapBufferRange");
+        return MapBufferRange(target, offset, length, access);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+    {
+        FlushMappedBufferRange = (PFNFLUSHMAPPEDBUFFERRANGEPROC)IntGetProcAddress("glFlushMappedBufferRange");
+        FlushMappedBufferRange(target, offset, length);
+    }
+
+    // Extension: ARB_framebuffer_object
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsRenderbuffer(GLuint renderbuffer)
+    {
+        IsRenderbuffer = (PFNISRENDERBUFFERPROC)IntGetProcAddress("glIsRenderbuffer");
+        return IsRenderbuffer(renderbuffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindRenderbuffer(GLenum target, GLuint renderbuffer)
+    {
+        BindRenderbuffer = (PFNBINDRENDERBUFFERPROC)IntGetProcAddress("glBindRenderbuffer");
+        BindRenderbuffer(target, renderbuffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
+    {
+        DeleteRenderbuffers = (PFNDELETERENDERBUFFERSPROC)IntGetProcAddress("glDeleteRenderbuffers");
+        DeleteRenderbuffers(n, renderbuffers);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
+    {
+        GenRenderbuffers = (PFNGENRENDERBUFFERSPROC)IntGetProcAddress("glGenRenderbuffers");
+        GenRenderbuffers(n, renderbuffers);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+    {
+        RenderbufferStorage = (PFNRENDERBUFFERSTORAGEPROC)IntGetProcAddress("glRenderbufferStorage");
+        RenderbufferStorage(target, internalformat, width, height);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
+    {
+        GetRenderbufferParameteriv = (PFNGETRENDERBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetRenderbufferParameteriv");
+        GetRenderbufferParameteriv(target, pname, params);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsFramebuffer(GLuint framebuffer)
+    {
+        IsFramebuffer = (PFNISFRAMEBUFFERPROC)IntGetProcAddress("glIsFramebuffer");
+        return IsFramebuffer(framebuffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindFramebuffer(GLenum target, GLuint framebuffer)
+    {
+        BindFramebuffer = (PFNBINDFRAMEBUFFERPROC)IntGetProcAddress("glBindFramebuffer");
+        BindFramebuffer(target, framebuffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
+    {
+        DeleteFramebuffers = (PFNDELETEFRAMEBUFFERSPROC)IntGetProcAddress("glDeleteFramebuffers");
+        DeleteFramebuffers(n, framebuffers);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenFramebuffers(GLsizei n, GLuint *framebuffers)
+    {
+        GenFramebuffers = (PFNGENFRAMEBUFFERSPROC)IntGetProcAddress("glGenFramebuffers");
+        GenFramebuffers(n, framebuffers);
+    }
+
+    static GLenum CODEGEN_FUNCPTR Switch_CheckFramebufferStatus(GLenum target)
+    {
+        CheckFramebufferStatus = (PFNCHECKFRAMEBUFFERSTATUSPROC)IntGetProcAddress("glCheckFramebufferStatus");
+        return CheckFramebufferStatus(target);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+    {
+        FramebufferTexture1D = (PFNFRAMEBUFFERTEXTURE1DPROC)IntGetProcAddress("glFramebufferTexture1D");
+        FramebufferTexture1D(target, attachment, textarget, texture, level);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+    {
+        FramebufferTexture2D = (PFNFRAMEBUFFERTEXTURE2DPROC)IntGetProcAddress("glFramebufferTexture2D");
+        FramebufferTexture2D(target, attachment, textarget, texture, level);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+    {
+        FramebufferTexture3D = (PFNFRAMEBUFFERTEXTURE3DPROC)IntGetProcAddress("glFramebufferTexture3D");
+        FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+    {
+        FramebufferRenderbuffer = (PFNFRAMEBUFFERRENDERBUFFERPROC)IntGetProcAddress("glFramebufferRenderbuffer");
+        FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
+    {
+        GetFramebufferAttachmentParameteriv = (PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)IntGetProcAddress("glGetFramebufferAttachmentParameteriv");
+        GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GenerateMipmap(GLenum target)
+    {
+        GenerateMipmap = (PFNGENERATEMIPMAPPROC)IntGetProcAddress("glGenerateMipmap");
+        GenerateMipmap(target);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+    {
+        BlitFramebuffer = (PFNBLITFRAMEBUFFERPROC)IntGetProcAddress("glBlitFramebuffer");
+        BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+    {
+        RenderbufferStorageMultisample = (PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)IntGetProcAddress("glRenderbufferStorageMultisample");
+        RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
+    {
+        FramebufferTextureLayer = (PFNFRAMEBUFFERTEXTURELAYERPROC)IntGetProcAddress("glFramebufferTextureLayer");
+        FramebufferTextureLayer(target, attachment, texture, level, layer);
+    }
+
+    // Extension: 3.0
+
+    static void CODEGEN_FUNCPTR Switch_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
+    {
+        ColorMaski = (PFNCOLORMASKIPROC)IntGetProcAddress("glColorMaski");
+        ColorMaski(index, r, g, b, a);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
+    {
+        GetBooleani_v = (PFNGETBOOLEANI_VPROC)IntGetProcAddress("glGetBooleani_v");
+        GetBooleani_v(target, index, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetIntegeri_v(GLenum target, GLuint index, GLint *data)
+    {
+        GetIntegeri_v = (PFNGETINTEGERI_VPROC)IntGetProcAddress("glGetIntegeri_v");
+        GetIntegeri_v(target, index, data);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Enablei(GLenum target, GLuint index)
+    {
+        Enablei = (PFNENABLEIPROC)IntGetProcAddress("glEnablei");
+        Enablei(target, index);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Disablei(GLenum target, GLuint index)
+    {
+        Disablei = (PFNDISABLEIPROC)IntGetProcAddress("glDisablei");
+        Disablei(target, index);
+    }
+
+    static GLboolean CODEGEN_FUNCPTR Switch_IsEnabledi(GLenum target, GLuint index)
+    {
+        IsEnabledi = (PFNISENABLEDIPROC)IntGetProcAddress("glIsEnabledi");
+        return IsEnabledi(target, index);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BeginTransformFeedback(GLenum primitiveMode)
+    {
+        BeginTransformFeedback = (PFNBEGINTRANSFORMFEEDBACKPROC)IntGetProcAddress("glBeginTransformFeedback");
+        BeginTransformFeedback(primitiveMode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_EndTransformFeedback()
+    {
+        EndTransformFeedback = (PFNENDTRANSFORMFEEDBACKPROC)IntGetProcAddress("glEndTransformFeedback");
+        EndTransformFeedback();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+    {
+        BindBufferRange = (PFNBINDBUFFERRANGEPROC)IntGetProcAddress("glBindBufferRange");
+        BindBufferRange(target, index, buffer, offset, size);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
+    {
+        BindBufferBase = (PFNBINDBUFFERBASEPROC)IntGetProcAddress("glBindBufferBase");
+        BindBufferBase(target, index, buffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
+    {
+        TransformFeedbackVaryings = (PFNTRANSFORMFEEDBACKVARYINGSPROC)IntGetProcAddress("glTransformFeedbackVaryings");
+        TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
+    {
+        GetTransformFeedbackVarying = (PFNGETTRANSFORMFEEDBACKVARYINGPROC)IntGetProcAddress("glGetTransformFeedbackVarying");
+        GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClampColor(GLenum target, GLenum clamp)
+    {
+        ClampColor = (PFNCLAMPCOLORPROC)IntGetProcAddress("glClampColor");
+        ClampColor(target, clamp);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BeginConditionalRender(GLuint id, GLenum mode)
+    {
+        BeginConditionalRender = (PFNBEGINCONDITIONALRENDERPROC)IntGetProcAddress("glBeginConditionalRender");
+        BeginConditionalRender(id, mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_EndConditionalRender()
+    {
+        EndConditionalRender = (PFNENDCONDITIONALRENDERPROC)IntGetProcAddress("glEndConditionalRender");
+        EndConditionalRender();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+    {
+        VertexAttribIPointer = (PFNVERTEXATTRIBIPOINTERPROC)IntGetProcAddress("glVertexAttribIPointer");
+        VertexAttribIPointer(index, size, type, stride, pointer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
+    {
+        GetVertexAttribIiv = (PFNGETVERTEXATTRIBIIVPROC)IntGetProcAddress("glGetVertexAttribIiv");
+        GetVertexAttribIiv(index, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
+    {
+        GetVertexAttribIuiv = (PFNGETVERTEXATTRIBIUIVPROC)IntGetProcAddress("glGetVertexAttribIuiv");
+        GetVertexAttribIuiv(index, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI1i(GLuint index, GLint x)
+    {
+        VertexAttribI1i = (PFNVERTEXATTRIBI1IPROC)IntGetProcAddress("glVertexAttribI1i");
+        VertexAttribI1i(index, x);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI2i(GLuint index, GLint x, GLint y)
+    {
+        VertexAttribI2i = (PFNVERTEXATTRIBI2IPROC)IntGetProcAddress("glVertexAttribI2i");
+        VertexAttribI2i(index, x, y);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
+    {
+        VertexAttribI3i = (PFNVERTEXATTRIBI3IPROC)IntGetProcAddress("glVertexAttribI3i");
+        VertexAttribI3i(index, x, y, z);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
+    {
+        VertexAttribI4i = (PFNVERTEXATTRIBI4IPROC)IntGetProcAddress("glVertexAttribI4i");
+        VertexAttribI4i(index, x, y, z, w);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI1ui(GLuint index, GLuint x)
+    {
+        VertexAttribI1ui = (PFNVERTEXATTRIBI1UIPROC)IntGetProcAddress("glVertexAttribI1ui");
+        VertexAttribI1ui(index, x);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
+    {
+        VertexAttribI2ui = (PFNVERTEXATTRIBI2UIPROC)IntGetProcAddress("glVertexAttribI2ui");
+        VertexAttribI2ui(index, x, y);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
+    {
+        VertexAttribI3ui = (PFNVERTEXATTRIBI3UIPROC)IntGetProcAddress("glVertexAttribI3ui");
+        VertexAttribI3ui(index, x, y, z);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+    {
+        VertexAttribI4ui = (PFNVERTEXATTRIBI4UIPROC)IntGetProcAddress("glVertexAttribI4ui");
+        VertexAttribI4ui(index, x, y, z, w);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI1iv(GLuint index, const GLint *v)
+    {
+        VertexAttribI1iv = (PFNVERTEXATTRIBI1IVPROC)IntGetProcAddress("glVertexAttribI1iv");
+        VertexAttribI1iv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI2iv(GLuint index, const GLint *v)
+    {
+        VertexAttribI2iv = (PFNVERTEXATTRIBI2IVPROC)IntGetProcAddress("glVertexAttribI2iv");
+        VertexAttribI2iv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI3iv(GLuint index, const GLint *v)
+    {
+        VertexAttribI3iv = (PFNVERTEXATTRIBI3IVPROC)IntGetProcAddress("glVertexAttribI3iv");
+        VertexAttribI3iv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4iv(GLuint index, const GLint *v)
+    {
+        VertexAttribI4iv = (PFNVERTEXATTRIBI4IVPROC)IntGetProcAddress("glVertexAttribI4iv");
+        VertexAttribI4iv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI1uiv(GLuint index, const GLuint *v)
+    {
+        VertexAttribI1uiv = (PFNVERTEXATTRIBI1UIVPROC)IntGetProcAddress("glVertexAttribI1uiv");
+        VertexAttribI1uiv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI2uiv(GLuint index, const GLuint *v)
+    {
+        VertexAttribI2uiv = (PFNVERTEXATTRIBI2UIVPROC)IntGetProcAddress("glVertexAttribI2uiv");
+        VertexAttribI2uiv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI3uiv(GLuint index, const GLuint *v)
+    {
+        VertexAttribI3uiv = (PFNVERTEXATTRIBI3UIVPROC)IntGetProcAddress("glVertexAttribI3uiv");
+        VertexAttribI3uiv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4uiv(GLuint index, const GLuint *v)
+    {
+        VertexAttribI4uiv = (PFNVERTEXATTRIBI4UIVPROC)IntGetProcAddress("glVertexAttribI4uiv");
+        VertexAttribI4uiv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4bv(GLuint index, const GLbyte *v)
+    {
+        VertexAttribI4bv = (PFNVERTEXATTRIBI4BVPROC)IntGetProcAddress("glVertexAttribI4bv");
+        VertexAttribI4bv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4sv(GLuint index, const GLshort *v)
+    {
+        VertexAttribI4sv = (PFNVERTEXATTRIBI4SVPROC)IntGetProcAddress("glVertexAttribI4sv");
+        VertexAttribI4sv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4ubv(GLuint index, const GLubyte *v)
+    {
+        VertexAttribI4ubv = (PFNVERTEXATTRIBI4UBVPROC)IntGetProcAddress("glVertexAttribI4ubv");
+        VertexAttribI4ubv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexAttribI4usv(GLuint index, const GLushort *v)
+    {
+        VertexAttribI4usv = (PFNVERTEXATTRIBI4USVPROC)IntGetProcAddress("glVertexAttribI4usv");
+        VertexAttribI4usv(index, v);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetUniformuiv(GLuint program, GLint location, GLuint *params)
+    {
+        GetUniformuiv = (PFNGETUNIFORMUIVPROC)IntGetProcAddress("glGetUniformuiv");
+        GetUniformuiv(program, location, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
+    {
+        BindFragDataLocation = (PFNBINDFRAGDATALOCATIONPROC)IntGetProcAddress("glBindFragDataLocation");
+        BindFragDataLocation(program, color, name);
+    }
+
+    static GLint CODEGEN_FUNCPTR Switch_GetFragDataLocation(GLuint program, const GLchar *name)
+    {
+        GetFragDataLocation = (PFNGETFRAGDATALOCATIONPROC)IntGetProcAddress("glGetFragDataLocation");
+        return GetFragDataLocation(program, name);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1ui(GLint location, GLuint v0)
+    {
+        Uniform1ui = (PFNUNIFORM1UIPROC)IntGetProcAddress("glUniform1ui");
+        Uniform1ui(location, v0);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2ui(GLint location, GLuint v0, GLuint v1)
+    {
+        Uniform2ui = (PFNUNIFORM2UIPROC)IntGetProcAddress("glUniform2ui");
+        Uniform2ui(location, v0, v1);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+    {
+        Uniform3ui = (PFNUNIFORM3UIPROC)IntGetProcAddress("glUniform3ui");
+        Uniform3ui(location, v0, v1, v2);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+    {
+        Uniform4ui = (PFNUNIFORM4UIPROC)IntGetProcAddress("glUniform4ui");
+        Uniform4ui(location, v0, v1, v2, v3);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform1uiv(GLint location, GLsizei count, const GLuint *value)
+    {
+        Uniform1uiv = (PFNUNIFORM1UIVPROC)IntGetProcAddress("glUniform1uiv");
+        Uniform1uiv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform2uiv(GLint location, GLsizei count, const GLuint *value)
+    {
+        Uniform2uiv = (PFNUNIFORM2UIVPROC)IntGetProcAddress("glUniform2uiv");
+        Uniform2uiv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform3uiv(GLint location, GLsizei count, const GLuint *value)
+    {
+        Uniform3uiv = (PFNUNIFORM3UIVPROC)IntGetProcAddress("glUniform3uiv");
+        Uniform3uiv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Uniform4uiv(GLint location, GLsizei count, const GLuint *value)
+    {
+        Uniform4uiv = (PFNUNIFORM4UIVPROC)IntGetProcAddress("glUniform4uiv");
+        Uniform4uiv(location, count, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameterIiv(GLenum target, GLenum pname, const GLint *params)
+    {
+        TexParameterIiv = (PFNTEXPARAMETERIIVPROC)IntGetProcAddress("glTexParameterIiv");
+        TexParameterIiv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
+    {
+        TexParameterIuiv = (PFNTEXPARAMETERIUIVPROC)IntGetProcAddress("glTexParameterIuiv");
+        TexParameterIuiv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
+    {
+        GetTexParameterIiv = (PFNGETTEXPARAMETERIIVPROC)IntGetProcAddress("glGetTexParameterIiv");
+        GetTexParameterIiv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
+    {
+        GetTexParameterIuiv = (PFNGETTEXPARAMETERIUIVPROC)IntGetProcAddress("glGetTexParameterIuiv");
+        GetTexParameterIuiv(target, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
+    {
+        ClearBufferiv = (PFNCLEARBUFFERIVPROC)IntGetProcAddress("glClearBufferiv");
+        ClearBufferiv(buffer, drawbuffer, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
+    {
+        ClearBufferuiv = (PFNCLEARBUFFERUIVPROC)IntGetProcAddress("glClearBufferuiv");
+        ClearBufferuiv(buffer, drawbuffer, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
+    {
+        ClearBufferfv = (PFNCLEARBUFFERFVPROC)IntGetProcAddress("glClearBufferfv");
+        ClearBufferfv(buffer, drawbuffer, value);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+    {
+        ClearBufferfi = (PFNCLEARBUFFERFIPROC)IntGetProcAddress("glClearBufferfi");
+        ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    }
+
+    static const GLubyte * CODEGEN_FUNCPTR Switch_GetStringi(GLenum name, GLuint index)
+    {
+        GetStringi = (PFNGETSTRINGIPROC)IntGetProcAddress("glGetStringi");
+        return GetStringi(name, index);
+    }
+
+    // Extension: ARB_uniform_buffer_object
+
+    static void CODEGEN_FUNCPTR Switch_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
+    {
+        GetUniformIndices = (PFNGETUNIFORMINDICESPROC)IntGetProcAddress("glGetUniformIndices");
+        GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
+    {
+        GetActiveUniformsiv = (PFNGETACTIVEUNIFORMSIVPROC)IntGetProcAddress("glGetActiveUniformsiv");
+        GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
+    {
+        GetActiveUniformName = (PFNGETACTIVEUNIFORMNAMEPROC)IntGetProcAddress("glGetActiveUniformName");
+        GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    }
+
+    static GLuint CODEGEN_FUNCPTR Switch_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
+    {
+        GetUniformBlockIndex = (PFNGETUNIFORMBLOCKINDEXPROC)IntGetProcAddress("glGetUniformBlockIndex");
+        return GetUniformBlockIndex(program, uniformBlockName);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
+    {
+        GetActiveUniformBlockiv = (PFNGETACTIVEUNIFORMBLOCKIVPROC)IntGetProcAddress("glGetActiveUniformBlockiv");
+        GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
+    {
+        GetActiveUniformBlockName = (PFNGETACTIVEUNIFORMBLOCKNAMEPROC)IntGetProcAddress("glGetActiveUniformBlockName");
+        GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+    {
+        UniformBlockBinding = (PFNUNIFORMBLOCKBINDINGPROC)IntGetProcAddress("glUniformBlockBinding");
+        UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    }
+
+    // Extension: ARB_copy_buffer
+
+    static void CODEGEN_FUNCPTR Switch_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+    {
+        CopyBufferSubData = (PFNCOPYBUFFERSUBDATAPROC)IntGetProcAddress("glCopyBufferSubData");
+        CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    }
+
+    // Extension: 3.1
+
+    static void CODEGEN_FUNCPTR Switch_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
+    {
+        DrawArraysInstanced = (PFNDRAWARRAYSINSTANCEDPROC)IntGetProcAddress("glDrawArraysInstanced");
+        DrawArraysInstanced(mode, first, count, instancecount);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
+    {
+        DrawElementsInstanced = (PFNDRAWELEMENTSINSTANCEDPROC)IntGetProcAddress("glDrawElementsInstanced");
+        DrawElementsInstanced(mode, count, type, indices, instancecount);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
+    {
+        TexBuffer = (PFNTEXBUFFERPROC)IntGetProcAddress("glTexBuffer");
+        TexBuffer(target, internalformat, buffer);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_PrimitiveRestartIndex(GLuint index)
+    {
+        PrimitiveRestartIndex = (PFNPRIMITIVERESTARTINDEXPROC)IntGetProcAddress("glPrimitiveRestartIndex");
+        PrimitiveRestartIndex(index);
+    }
+
+    // Legacy
+
+    static void CODEGEN_FUNCPTR Switch_EnableClientState(GLenum cap)
+    {
+        EnableClientState = (PFNENABLECLIENTSTATEPROC)IntGetProcAddress("glEnableClientState");
+        EnableClientState(cap);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_DisableClientState(GLenum cap)
+    {
+        DisableClientState = (PFNDISABLECLIENTSTATEPROC)IntGetProcAddress("glDisableClientState");
+        DisableClientState(cap);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+    {
+        VertexPointer = (PFNVERTEXPOINTERPROC)IntGetProcAddress("glVertexPointer");
+        VertexPointer(size, type, stride, ptr);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+    {
+        NormalPointer = (PFNNORMALPOINTERPROC)IntGetProcAddress("glNormalPointer");
+        NormalPointer(type, stride, ptr);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+    {
+        ColorPointer = (PFNCOLORPOINTERPROC)IntGetProcAddress("glColorPointer");
+        ColorPointer(size, type, stride, ptr);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+    {
+        TexCoordPointer = (PFNTEXCOORDPOINTERPROC)IntGetProcAddress("glTexCoordPointer");
+        TexCoordPointer(size, type, stride, ptr);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_TexEnvi(GLenum target, GLenum pname, GLint param)
+    {
+        TexEnvi = (PFNTEXENVIPROC)IntGetProcAddress("glTexEnvi");
+        TexEnvi(target, pname, param);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_MatrixMode(GLenum mode)
+    {
+        MatrixMode = (PFNMATRIXMODEPROC)IntGetProcAddress("glMatrixMode");
+        MatrixMode(mode);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_LoadIdentity(void)
+    {
+        LoadIdentity = (PFNLOADIDENTITYPROC)IntGetProcAddress("glLoadIdentity");
+        LoadIdentity();
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val)
+    {
+        Ortho = (PFNORTHOPROC)IntGetProcAddress("glOrtho");
+        Ortho(left, right, bottom, top, near_val, far_val);
+    }
+
+    static void CODEGEN_FUNCPTR Switch_Color3d(GLdouble red, GLdouble green, GLdouble blue)
+    {
+        Color3d = (PFNCOLOR3DPROC)IntGetProcAddress("glColor3d");
+        Color3d(red, green, blue);
+    }
+
     struct InitializeVariables
     {
-      InitializeVariables()
-      {
-        // Extension: 1.1
-        CullFace = Switch_CullFace;
-        FrontFace = Switch_FrontFace;
-        Hint = Switch_Hint;
-        LineWidth = Switch_LineWidth;
-        PointSize = Switch_PointSize;
-        PolygonMode = Switch_PolygonMode;
-        Scissor = Switch_Scissor;
-        TexParameterf = Switch_TexParameterf;
-        TexParameterfv = Switch_TexParameterfv;
-        TexParameteri = Switch_TexParameteri;
-        TexParameteriv = Switch_TexParameteriv;
-        TexImage1D = Switch_TexImage1D;
-        TexImage2D = Switch_TexImage2D;
-        DrawBuffer = Switch_DrawBuffer;
-        Clear = Switch_Clear;
-        ClearColor = Switch_ClearColor;
-        ClearStencil = Switch_ClearStencil;
-        ClearDepth = Switch_ClearDepth;
-        StencilMask = Switch_StencilMask;
-        ColorMask = Switch_ColorMask;
-        DepthMask = Switch_DepthMask;
-        Disable = Switch_Disable;
-        Enable = Switch_Enable;
-        Finish = Switch_Finish;
-        Flush = Switch_Flush;
-        BlendFunc = Switch_BlendFunc;
-        LogicOp = Switch_LogicOp;
-        StencilFunc = Switch_StencilFunc;
-        StencilOp = Switch_StencilOp;
-        DepthFunc = Switch_DepthFunc;
-        PixelStoref = Switch_PixelStoref;
-        PixelStorei = Switch_PixelStorei;
-        ReadBuffer = Switch_ReadBuffer;
-        ReadPixels = Switch_ReadPixels;
-        GetBooleanv = Switch_GetBooleanv;
-        GetDoublev = Switch_GetDoublev;
-        GetError = Switch_GetError;
-        GetFloatv = Switch_GetFloatv;
-        GetIntegerv = Switch_GetIntegerv;
-        GetString = Switch_GetString;
-        GetTexImage = Switch_GetTexImage;
-        GetTexParameterfv = Switch_GetTexParameterfv;
-        GetTexParameteriv = Switch_GetTexParameteriv;
-        GetTexLevelParameterfv = Switch_GetTexLevelParameterfv;
-        GetTexLevelParameteriv = Switch_GetTexLevelParameteriv;
-        IsEnabled = Switch_IsEnabled;
-        DepthRange = Switch_DepthRange;
-        Viewport = Switch_Viewport;
-        DrawArrays = Switch_DrawArrays;
-        DrawElements = Switch_DrawElements;
-        GetPointerv = Switch_GetPointerv;
-        PolygonOffset = Switch_PolygonOffset;
-        CopyTexImage1D = Switch_CopyTexImage1D;
-        CopyTexImage2D = Switch_CopyTexImage2D;
-        CopyTexSubImage1D = Switch_CopyTexSubImage1D;
-        CopyTexSubImage2D = Switch_CopyTexSubImage2D;
-        TexSubImage1D = Switch_TexSubImage1D;
-        TexSubImage2D = Switch_TexSubImage2D;
-        BindTexture = Switch_BindTexture;
-        DeleteTextures = Switch_DeleteTextures;
-        GenTextures = Switch_GenTextures;
-        IsTexture = Switch_IsTexture;
-        Indexub = Switch_Indexub;
-        Indexubv = Switch_Indexubv;
+        InitializeVariables()
+        {
+            // Extension: 1.1
+            CullFace = Switch_CullFace;
+            FrontFace = Switch_FrontFace;
+            Hint = Switch_Hint;
+            LineWidth = Switch_LineWidth;
+            PointSize = Switch_PointSize;
+            PolygonMode = Switch_PolygonMode;
+            Scissor = Switch_Scissor;
+            TexParameterf = Switch_TexParameterf;
+            TexParameterfv = Switch_TexParameterfv;
+            TexParameteri = Switch_TexParameteri;
+            TexParameteriv = Switch_TexParameteriv;
+            TexImage1D = Switch_TexImage1D;
+            TexImage2D = Switch_TexImage2D;
+            DrawBuffer = Switch_DrawBuffer;
+            Clear = Switch_Clear;
+            ClearColor = Switch_ClearColor;
+            ClearStencil = Switch_ClearStencil;
+            ClearDepth = Switch_ClearDepth;
+            StencilMask = Switch_StencilMask;
+            ColorMask = Switch_ColorMask;
+            DepthMask = Switch_DepthMask;
+            Disable = Switch_Disable;
+            Enable = Switch_Enable;
+            Finish = Switch_Finish;
+            Flush = Switch_Flush;
+            BlendFunc = Switch_BlendFunc;
+            LogicOp = Switch_LogicOp;
+            StencilFunc = Switch_StencilFunc;
+            StencilOp = Switch_StencilOp;
+            DepthFunc = Switch_DepthFunc;
+            PixelStoref = Switch_PixelStoref;
+            PixelStorei = Switch_PixelStorei;
+            ReadBuffer = Switch_ReadBuffer;
+            ReadPixels = Switch_ReadPixels;
+            GetBooleanv = Switch_GetBooleanv;
+            GetDoublev = Switch_GetDoublev;
+            GetError = Switch_GetError;
+            GetFloatv = Switch_GetFloatv;
+            GetIntegerv = Switch_GetIntegerv;
+            GetString = Switch_GetString;
+            GetTexImage = Switch_GetTexImage;
+            GetTexParameterfv = Switch_GetTexParameterfv;
+            GetTexParameteriv = Switch_GetTexParameteriv;
+            GetTexLevelParameterfv = Switch_GetTexLevelParameterfv;
+            GetTexLevelParameteriv = Switch_GetTexLevelParameteriv;
+            IsEnabled = Switch_IsEnabled;
+            DepthRange = Switch_DepthRange;
+            Viewport = Switch_Viewport;
+            DrawArrays = Switch_DrawArrays;
+            DrawElements = Switch_DrawElements;
+            GetPointerv = Switch_GetPointerv;
+            PolygonOffset = Switch_PolygonOffset;
+            CopyTexImage1D = Switch_CopyTexImage1D;
+            CopyTexImage2D = Switch_CopyTexImage2D;
+            CopyTexSubImage1D = Switch_CopyTexSubImage1D;
+            CopyTexSubImage2D = Switch_CopyTexSubImage2D;
+            TexSubImage1D = Switch_TexSubImage1D;
+            TexSubImage2D = Switch_TexSubImage2D;
+            BindTexture = Switch_BindTexture;
+            DeleteTextures = Switch_DeleteTextures;
+            GenTextures = Switch_GenTextures;
+            IsTexture = Switch_IsTexture;
+            Indexub = Switch_Indexub;
+            Indexubv = Switch_Indexubv;
 
-        // Extension: 1.2
-        BlendColor = Switch_BlendColor;
-        BlendEquation = Switch_BlendEquation;
-        DrawRangeElements = Switch_DrawRangeElements;
-        TexSubImage3D = Switch_TexSubImage3D;
-        CopyTexSubImage3D = Switch_CopyTexSubImage3D;
+            // Extension: 1.2
+            BlendColor = Switch_BlendColor;
+            BlendEquation = Switch_BlendEquation;
+            DrawRangeElements = Switch_DrawRangeElements;
+            TexSubImage3D = Switch_TexSubImage3D;
+            CopyTexSubImage3D = Switch_CopyTexSubImage3D;
 
-        // Extension: 1.3
-        ActiveTexture = Switch_ActiveTexture;
-        SampleCoverage = Switch_SampleCoverage;
-        CompressedTexImage3D = Switch_CompressedTexImage3D;
-        CompressedTexImage2D = Switch_CompressedTexImage2D;
-        CompressedTexImage1D = Switch_CompressedTexImage1D;
-        CompressedTexSubImage3D = Switch_CompressedTexSubImage3D;
-        CompressedTexSubImage2D = Switch_CompressedTexSubImage2D;
-        CompressedTexSubImage1D = Switch_CompressedTexSubImage1D;
-        GetCompressedTexImage = Switch_GetCompressedTexImage;
+            // Extension: 1.3
+            ActiveTexture = Switch_ActiveTexture;
+            SampleCoverage = Switch_SampleCoverage;
+            CompressedTexImage3D = Switch_CompressedTexImage3D;
+            CompressedTexImage2D = Switch_CompressedTexImage2D;
+            CompressedTexImage1D = Switch_CompressedTexImage1D;
+            CompressedTexSubImage3D = Switch_CompressedTexSubImage3D;
+            CompressedTexSubImage2D = Switch_CompressedTexSubImage2D;
+            CompressedTexSubImage1D = Switch_CompressedTexSubImage1D;
+            GetCompressedTexImage = Switch_GetCompressedTexImage;
 
-        // Extension: 1.4
-        BlendFuncSeparate = Switch_BlendFuncSeparate;
-        MultiDrawArrays = Switch_MultiDrawArrays;
-        MultiDrawElements = Switch_MultiDrawElements;
-        PointParameterf = Switch_PointParameterf;
-        PointParameterfv = Switch_PointParameterfv;
-        PointParameteri = Switch_PointParameteri;
-        PointParameteriv = Switch_PointParameteriv;
+            // Extension: 1.4
+            BlendFuncSeparate = Switch_BlendFuncSeparate;
+            MultiDrawArrays = Switch_MultiDrawArrays;
+            MultiDrawElements = Switch_MultiDrawElements;
+            PointParameterf = Switch_PointParameterf;
+            PointParameterfv = Switch_PointParameterfv;
+            PointParameteri = Switch_PointParameteri;
+            PointParameteriv = Switch_PointParameteriv;
 
-        // Extension: 1.5
-        GenQueries = Switch_GenQueries;
-        DeleteQueries = Switch_DeleteQueries;
-        IsQuery = Switch_IsQuery;
-        BeginQuery = Switch_BeginQuery;
-        EndQuery = Switch_EndQuery;
-        GetQueryiv = Switch_GetQueryiv;
-        GetQueryObjectiv = Switch_GetQueryObjectiv;
-        GetQueryObjectuiv = Switch_GetQueryObjectuiv;
-        BindBuffer = Switch_BindBuffer;
-        DeleteBuffers = Switch_DeleteBuffers;
-        GenBuffers = Switch_GenBuffers;
-        IsBuffer = Switch_IsBuffer;
-        BufferData = Switch_BufferData;
-        BufferSubData = Switch_BufferSubData;
-        GetBufferSubData = Switch_GetBufferSubData;
-        MapBuffer = Switch_MapBuffer;
-        UnmapBuffer = Switch_UnmapBuffer;
-        GetBufferParameteriv = Switch_GetBufferParameteriv;
-        GetBufferPointerv = Switch_GetBufferPointerv;
+            // Extension: 1.5
+            GenQueries = Switch_GenQueries;
+            DeleteQueries = Switch_DeleteQueries;
+            IsQuery = Switch_IsQuery;
+            BeginQuery = Switch_BeginQuery;
+            EndQuery = Switch_EndQuery;
+            GetQueryiv = Switch_GetQueryiv;
+            GetQueryObjectiv = Switch_GetQueryObjectiv;
+            GetQueryObjectuiv = Switch_GetQueryObjectuiv;
+            BindBuffer = Switch_BindBuffer;
+            DeleteBuffers = Switch_DeleteBuffers;
+            GenBuffers = Switch_GenBuffers;
+            IsBuffer = Switch_IsBuffer;
+            BufferData = Switch_BufferData;
+            BufferSubData = Switch_BufferSubData;
+            GetBufferSubData = Switch_GetBufferSubData;
+            MapBuffer = Switch_MapBuffer;
+            UnmapBuffer = Switch_UnmapBuffer;
+            GetBufferParameteriv = Switch_GetBufferParameteriv;
+            GetBufferPointerv = Switch_GetBufferPointerv;
 
-        // Extension: 2.0
-        BlendEquationSeparate = Switch_BlendEquationSeparate;
-        DrawBuffers = Switch_DrawBuffers;
-        StencilOpSeparate = Switch_StencilOpSeparate;
-        StencilFuncSeparate = Switch_StencilFuncSeparate;
-        StencilMaskSeparate = Switch_StencilMaskSeparate;
-        AttachShader = Switch_AttachShader;
-        BindAttribLocation = Switch_BindAttribLocation;
-        CompileShader = Switch_CompileShader;
-        CreateProgram = Switch_CreateProgram;
-        CreateShader = Switch_CreateShader;
-        DeleteProgram = Switch_DeleteProgram;
-        DeleteShader = Switch_DeleteShader;
-        DetachShader = Switch_DetachShader;
-        DisableVertexAttribArray = Switch_DisableVertexAttribArray;
-        EnableVertexAttribArray = Switch_EnableVertexAttribArray;
-        GetActiveAttrib = Switch_GetActiveAttrib;
-        GetActiveUniform = Switch_GetActiveUniform;
-        GetAttachedShaders = Switch_GetAttachedShaders;
-        GetAttribLocation = Switch_GetAttribLocation;
-        GetProgramiv = Switch_GetProgramiv;
-        GetProgramInfoLog = Switch_GetProgramInfoLog;
-        GetShaderiv = Switch_GetShaderiv;
-        GetShaderInfoLog = Switch_GetShaderInfoLog;
-        GetShaderSource = Switch_GetShaderSource;
-        GetUniformLocation = Switch_GetUniformLocation;
-        GetUniformfv = Switch_GetUniformfv;
-        GetUniformiv = Switch_GetUniformiv;
-        GetVertexAttribdv = Switch_GetVertexAttribdv;
-        GetVertexAttribfv = Switch_GetVertexAttribfv;
-        GetVertexAttribiv = Switch_GetVertexAttribiv;
-        GetVertexAttribPointerv = Switch_GetVertexAttribPointerv;
-        IsProgram = Switch_IsProgram;
-        IsShader = Switch_IsShader;
-        LinkProgram = Switch_LinkProgram;
-        ShaderSource = Switch_ShaderSource;
-        UseProgram = Switch_UseProgram;
-        Uniform1f = Switch_Uniform1f;
-        Uniform2f = Switch_Uniform2f;
-        Uniform3f = Switch_Uniform3f;
-        Uniform4f = Switch_Uniform4f;
-        Uniform1i = Switch_Uniform1i;
-        Uniform2i = Switch_Uniform2i;
-        Uniform3i = Switch_Uniform3i;
-        Uniform4i = Switch_Uniform4i;
-        Uniform1fv = Switch_Uniform1fv;
-        Uniform2fv = Switch_Uniform2fv;
-        Uniform3fv = Switch_Uniform3fv;
-        Uniform4fv = Switch_Uniform4fv;
-        Uniform1iv = Switch_Uniform1iv;
-        Uniform2iv = Switch_Uniform2iv;
-        Uniform3iv = Switch_Uniform3iv;
-        Uniform4iv = Switch_Uniform4iv;
-        UniformMatrix2fv = Switch_UniformMatrix2fv;
-        UniformMatrix3fv = Switch_UniformMatrix3fv;
-        UniformMatrix4fv = Switch_UniformMatrix4fv;
-        ValidateProgram = Switch_ValidateProgram;
-        VertexAttribPointer = Switch_VertexAttribPointer;
+            // Extension: 2.0
+            BlendEquationSeparate = Switch_BlendEquationSeparate;
+            DrawBuffers = Switch_DrawBuffers;
+            StencilOpSeparate = Switch_StencilOpSeparate;
+            StencilFuncSeparate = Switch_StencilFuncSeparate;
+            StencilMaskSeparate = Switch_StencilMaskSeparate;
+            AttachShader = Switch_AttachShader;
+            BindAttribLocation = Switch_BindAttribLocation;
+            CompileShader = Switch_CompileShader;
+            CreateProgram = Switch_CreateProgram;
+            CreateShader = Switch_CreateShader;
+            DeleteProgram = Switch_DeleteProgram;
+            DeleteShader = Switch_DeleteShader;
+            DetachShader = Switch_DetachShader;
+            DisableVertexAttribArray = Switch_DisableVertexAttribArray;
+            EnableVertexAttribArray = Switch_EnableVertexAttribArray;
+            GetActiveAttrib = Switch_GetActiveAttrib;
+            GetActiveUniform = Switch_GetActiveUniform;
+            GetAttachedShaders = Switch_GetAttachedShaders;
+            GetAttribLocation = Switch_GetAttribLocation;
+            GetProgramiv = Switch_GetProgramiv;
+            GetProgramInfoLog = Switch_GetProgramInfoLog;
+            GetShaderiv = Switch_GetShaderiv;
+            GetShaderInfoLog = Switch_GetShaderInfoLog;
+            GetShaderSource = Switch_GetShaderSource;
+            GetUniformLocation = Switch_GetUniformLocation;
+            GetUniformfv = Switch_GetUniformfv;
+            GetUniformiv = Switch_GetUniformiv;
+            GetVertexAttribdv = Switch_GetVertexAttribdv;
+            GetVertexAttribfv = Switch_GetVertexAttribfv;
+            GetVertexAttribiv = Switch_GetVertexAttribiv;
+            GetVertexAttribPointerv = Switch_GetVertexAttribPointerv;
+            IsProgram = Switch_IsProgram;
+            IsShader = Switch_IsShader;
+            LinkProgram = Switch_LinkProgram;
+            ShaderSource = Switch_ShaderSource;
+            UseProgram = Switch_UseProgram;
+            Uniform1f = Switch_Uniform1f;
+            Uniform2f = Switch_Uniform2f;
+            Uniform3f = Switch_Uniform3f;
+            Uniform4f = Switch_Uniform4f;
+            Uniform1i = Switch_Uniform1i;
+            Uniform2i = Switch_Uniform2i;
+            Uniform3i = Switch_Uniform3i;
+            Uniform4i = Switch_Uniform4i;
+            Uniform1fv = Switch_Uniform1fv;
+            Uniform2fv = Switch_Uniform2fv;
+            Uniform3fv = Switch_Uniform3fv;
+            Uniform4fv = Switch_Uniform4fv;
+            Uniform1iv = Switch_Uniform1iv;
+            Uniform2iv = Switch_Uniform2iv;
+            Uniform3iv = Switch_Uniform3iv;
+            Uniform4iv = Switch_Uniform4iv;
+            UniformMatrix2fv = Switch_UniformMatrix2fv;
+            UniformMatrix3fv = Switch_UniformMatrix3fv;
+            UniformMatrix4fv = Switch_UniformMatrix4fv;
+            ValidateProgram = Switch_ValidateProgram;
+            VertexAttribPointer = Switch_VertexAttribPointer;
 
-        // Extension: 2.1
-        UniformMatrix2x3fv = Switch_UniformMatrix2x3fv;
-        UniformMatrix3x2fv = Switch_UniformMatrix3x2fv;
-        UniformMatrix2x4fv = Switch_UniformMatrix2x4fv;
-        UniformMatrix4x2fv = Switch_UniformMatrix4x2fv;
-        UniformMatrix3x4fv = Switch_UniformMatrix3x4fv;
-        UniformMatrix4x3fv = Switch_UniformMatrix4x3fv;
+            // Extension: 2.1
+            UniformMatrix2x3fv = Switch_UniformMatrix2x3fv;
+            UniformMatrix3x2fv = Switch_UniformMatrix3x2fv;
+            UniformMatrix2x4fv = Switch_UniformMatrix2x4fv;
+            UniformMatrix4x2fv = Switch_UniformMatrix4x2fv;
+            UniformMatrix3x4fv = Switch_UniformMatrix3x4fv;
+            UniformMatrix4x3fv = Switch_UniformMatrix4x3fv;
 
-        // Extension: ARB_vertex_array_object
-        BindVertexArray = Switch_BindVertexArray;
-        DeleteVertexArrays = Switch_DeleteVertexArrays;
-        GenVertexArrays = Switch_GenVertexArrays;
-        IsVertexArray = Switch_IsVertexArray;
+            // Extension: ARB_vertex_array_object
+            BindVertexArray = Switch_BindVertexArray;
+            DeleteVertexArrays = Switch_DeleteVertexArrays;
+            GenVertexArrays = Switch_GenVertexArrays;
+            IsVertexArray = Switch_IsVertexArray;
 
-        // Extension: ARB_map_buffer_range
-        MapBufferRange = Switch_MapBufferRange;
-        FlushMappedBufferRange = Switch_FlushMappedBufferRange;
+            // Extension: ARB_map_buffer_range
+            MapBufferRange = Switch_MapBufferRange;
+            FlushMappedBufferRange = Switch_FlushMappedBufferRange;
 
-        // Extension: ARB_framebuffer_object
-        IsRenderbuffer = Switch_IsRenderbuffer;
-        BindRenderbuffer = Switch_BindRenderbuffer;
-        DeleteRenderbuffers = Switch_DeleteRenderbuffers;
-        GenRenderbuffers = Switch_GenRenderbuffers;
-        RenderbufferStorage = Switch_RenderbufferStorage;
-        GetRenderbufferParameteriv = Switch_GetRenderbufferParameteriv;
-        IsFramebuffer = Switch_IsFramebuffer;
-        BindFramebuffer = Switch_BindFramebuffer;
-        DeleteFramebuffers = Switch_DeleteFramebuffers;
-        GenFramebuffers = Switch_GenFramebuffers;
-        CheckFramebufferStatus = Switch_CheckFramebufferStatus;
-        FramebufferTexture1D = Switch_FramebufferTexture1D;
-        FramebufferTexture2D = Switch_FramebufferTexture2D;
-        FramebufferTexture3D = Switch_FramebufferTexture3D;
-        FramebufferRenderbuffer = Switch_FramebufferRenderbuffer;
-        GetFramebufferAttachmentParameteriv = Switch_GetFramebufferAttachmentParameteriv;
-        GenerateMipmap = Switch_GenerateMipmap;
-        BlitFramebuffer = Switch_BlitFramebuffer;
-        RenderbufferStorageMultisample = Switch_RenderbufferStorageMultisample;
-        FramebufferTextureLayer = Switch_FramebufferTextureLayer;
+            // Extension: ARB_framebuffer_object
+            IsRenderbuffer = Switch_IsRenderbuffer;
+            BindRenderbuffer = Switch_BindRenderbuffer;
+            DeleteRenderbuffers = Switch_DeleteRenderbuffers;
+            GenRenderbuffers = Switch_GenRenderbuffers;
+            RenderbufferStorage = Switch_RenderbufferStorage;
+            GetRenderbufferParameteriv = Switch_GetRenderbufferParameteriv;
+            IsFramebuffer = Switch_IsFramebuffer;
+            BindFramebuffer = Switch_BindFramebuffer;
+            DeleteFramebuffers = Switch_DeleteFramebuffers;
+            GenFramebuffers = Switch_GenFramebuffers;
+            CheckFramebufferStatus = Switch_CheckFramebufferStatus;
+            FramebufferTexture1D = Switch_FramebufferTexture1D;
+            FramebufferTexture2D = Switch_FramebufferTexture2D;
+            FramebufferTexture3D = Switch_FramebufferTexture3D;
+            FramebufferRenderbuffer = Switch_FramebufferRenderbuffer;
+            GetFramebufferAttachmentParameteriv = Switch_GetFramebufferAttachmentParameteriv;
+            GenerateMipmap = Switch_GenerateMipmap;
+            BlitFramebuffer = Switch_BlitFramebuffer;
+            RenderbufferStorageMultisample = Switch_RenderbufferStorageMultisample;
+            FramebufferTextureLayer = Switch_FramebufferTextureLayer;
 
-        // Extension: 3.0
-        ColorMaski = Switch_ColorMaski;
-        GetBooleani_v = Switch_GetBooleani_v;
-        GetIntegeri_v = Switch_GetIntegeri_v;
-        Enablei = Switch_Enablei;
-        Disablei = Switch_Disablei;
-        IsEnabledi = Switch_IsEnabledi;
-        BeginTransformFeedback = Switch_BeginTransformFeedback;
-        EndTransformFeedback = Switch_EndTransformFeedback;
-        BindBufferRange = Switch_BindBufferRange;
-        BindBufferBase = Switch_BindBufferBase;
-        TransformFeedbackVaryings = Switch_TransformFeedbackVaryings;
-        GetTransformFeedbackVarying = Switch_GetTransformFeedbackVarying;
-        ClampColor = Switch_ClampColor;
-        BeginConditionalRender = Switch_BeginConditionalRender;
-        EndConditionalRender = Switch_EndConditionalRender;
-        VertexAttribIPointer = Switch_VertexAttribIPointer;
-        GetVertexAttribIiv = Switch_GetVertexAttribIiv;
-        GetVertexAttribIuiv = Switch_GetVertexAttribIuiv;
-        VertexAttribI1i = Switch_VertexAttribI1i;
-        VertexAttribI2i = Switch_VertexAttribI2i;
-        VertexAttribI3i = Switch_VertexAttribI3i;
-        VertexAttribI4i = Switch_VertexAttribI4i;
-        VertexAttribI1ui = Switch_VertexAttribI1ui;
-        VertexAttribI2ui = Switch_VertexAttribI2ui;
-        VertexAttribI3ui = Switch_VertexAttribI3ui;
-        VertexAttribI4ui = Switch_VertexAttribI4ui;
-        VertexAttribI1iv = Switch_VertexAttribI1iv;
-        VertexAttribI2iv = Switch_VertexAttribI2iv;
-        VertexAttribI3iv = Switch_VertexAttribI3iv;
-        VertexAttribI4iv = Switch_VertexAttribI4iv;
-        VertexAttribI1uiv = Switch_VertexAttribI1uiv;
-        VertexAttribI2uiv = Switch_VertexAttribI2uiv;
-        VertexAttribI3uiv = Switch_VertexAttribI3uiv;
-        VertexAttribI4uiv = Switch_VertexAttribI4uiv;
-        VertexAttribI4bv = Switch_VertexAttribI4bv;
-        VertexAttribI4sv = Switch_VertexAttribI4sv;
-        VertexAttribI4ubv = Switch_VertexAttribI4ubv;
-        VertexAttribI4usv = Switch_VertexAttribI4usv;
-        GetUniformuiv = Switch_GetUniformuiv;
-        BindFragDataLocation = Switch_BindFragDataLocation;
-        GetFragDataLocation = Switch_GetFragDataLocation;
-        Uniform1ui = Switch_Uniform1ui;
-        Uniform2ui = Switch_Uniform2ui;
-        Uniform3ui = Switch_Uniform3ui;
-        Uniform4ui = Switch_Uniform4ui;
-        Uniform1uiv = Switch_Uniform1uiv;
-        Uniform2uiv = Switch_Uniform2uiv;
-        Uniform3uiv = Switch_Uniform3uiv;
-        Uniform4uiv = Switch_Uniform4uiv;
-        TexParameterIiv = Switch_TexParameterIiv;
-        TexParameterIuiv = Switch_TexParameterIuiv;
-        GetTexParameterIiv = Switch_GetTexParameterIiv;
-        GetTexParameterIuiv = Switch_GetTexParameterIuiv;
-        ClearBufferiv = Switch_ClearBufferiv;
-        ClearBufferuiv = Switch_ClearBufferuiv;
-        ClearBufferfv = Switch_ClearBufferfv;
-        ClearBufferfi = Switch_ClearBufferfi;
-        GetStringi = Switch_GetStringi;
+            // Extension: 3.0
+            ColorMaski = Switch_ColorMaski;
+            GetBooleani_v = Switch_GetBooleani_v;
+            GetIntegeri_v = Switch_GetIntegeri_v;
+            Enablei = Switch_Enablei;
+            Disablei = Switch_Disablei;
+            IsEnabledi = Switch_IsEnabledi;
+            BeginTransformFeedback = Switch_BeginTransformFeedback;
+            EndTransformFeedback = Switch_EndTransformFeedback;
+            BindBufferRange = Switch_BindBufferRange;
+            BindBufferBase = Switch_BindBufferBase;
+            TransformFeedbackVaryings = Switch_TransformFeedbackVaryings;
+            GetTransformFeedbackVarying = Switch_GetTransformFeedbackVarying;
+            ClampColor = Switch_ClampColor;
+            BeginConditionalRender = Switch_BeginConditionalRender;
+            EndConditionalRender = Switch_EndConditionalRender;
+            VertexAttribIPointer = Switch_VertexAttribIPointer;
+            GetVertexAttribIiv = Switch_GetVertexAttribIiv;
+            GetVertexAttribIuiv = Switch_GetVertexAttribIuiv;
+            VertexAttribI1i = Switch_VertexAttribI1i;
+            VertexAttribI2i = Switch_VertexAttribI2i;
+            VertexAttribI3i = Switch_VertexAttribI3i;
+            VertexAttribI4i = Switch_VertexAttribI4i;
+            VertexAttribI1ui = Switch_VertexAttribI1ui;
+            VertexAttribI2ui = Switch_VertexAttribI2ui;
+            VertexAttribI3ui = Switch_VertexAttribI3ui;
+            VertexAttribI4ui = Switch_VertexAttribI4ui;
+            VertexAttribI1iv = Switch_VertexAttribI1iv;
+            VertexAttribI2iv = Switch_VertexAttribI2iv;
+            VertexAttribI3iv = Switch_VertexAttribI3iv;
+            VertexAttribI4iv = Switch_VertexAttribI4iv;
+            VertexAttribI1uiv = Switch_VertexAttribI1uiv;
+            VertexAttribI2uiv = Switch_VertexAttribI2uiv;
+            VertexAttribI3uiv = Switch_VertexAttribI3uiv;
+            VertexAttribI4uiv = Switch_VertexAttribI4uiv;
+            VertexAttribI4bv = Switch_VertexAttribI4bv;
+            VertexAttribI4sv = Switch_VertexAttribI4sv;
+            VertexAttribI4ubv = Switch_VertexAttribI4ubv;
+            VertexAttribI4usv = Switch_VertexAttribI4usv;
+            GetUniformuiv = Switch_GetUniformuiv;
+            BindFragDataLocation = Switch_BindFragDataLocation;
+            GetFragDataLocation = Switch_GetFragDataLocation;
+            Uniform1ui = Switch_Uniform1ui;
+            Uniform2ui = Switch_Uniform2ui;
+            Uniform3ui = Switch_Uniform3ui;
+            Uniform4ui = Switch_Uniform4ui;
+            Uniform1uiv = Switch_Uniform1uiv;
+            Uniform2uiv = Switch_Uniform2uiv;
+            Uniform3uiv = Switch_Uniform3uiv;
+            Uniform4uiv = Switch_Uniform4uiv;
+            TexParameterIiv = Switch_TexParameterIiv;
+            TexParameterIuiv = Switch_TexParameterIuiv;
+            GetTexParameterIiv = Switch_GetTexParameterIiv;
+            GetTexParameterIuiv = Switch_GetTexParameterIuiv;
+            ClearBufferiv = Switch_ClearBufferiv;
+            ClearBufferuiv = Switch_ClearBufferuiv;
+            ClearBufferfv = Switch_ClearBufferfv;
+            ClearBufferfi = Switch_ClearBufferfi;
+            GetStringi = Switch_GetStringi;
 
-        // Extension: ARB_uniform_buffer_object
-        GetUniformIndices = Switch_GetUniformIndices;
-        GetActiveUniformsiv = Switch_GetActiveUniformsiv;
-        GetActiveUniformName = Switch_GetActiveUniformName;
-        GetUniformBlockIndex = Switch_GetUniformBlockIndex;
-        GetActiveUniformBlockiv = Switch_GetActiveUniformBlockiv;
-        GetActiveUniformBlockName = Switch_GetActiveUniformBlockName;
-        UniformBlockBinding = Switch_UniformBlockBinding;
+            // Extension: ARB_uniform_buffer_object
+            GetUniformIndices = Switch_GetUniformIndices;
+            GetActiveUniformsiv = Switch_GetActiveUniformsiv;
+            GetActiveUniformName = Switch_GetActiveUniformName;
+            GetUniformBlockIndex = Switch_GetUniformBlockIndex;
+            GetActiveUniformBlockiv = Switch_GetActiveUniformBlockiv;
+            GetActiveUniformBlockName = Switch_GetActiveUniformBlockName;
+            UniformBlockBinding = Switch_UniformBlockBinding;
 
-        // Extension: ARB_copy_buffer
-        CopyBufferSubData = Switch_CopyBufferSubData;
+            // Extension: ARB_copy_buffer
+            CopyBufferSubData = Switch_CopyBufferSubData;
 
-        // Extension: 3.1
-        DrawArraysInstanced = Switch_DrawArraysInstanced;
-        DrawElementsInstanced = Switch_DrawElementsInstanced;
-        TexBuffer = Switch_TexBuffer;
-        PrimitiveRestartIndex = Switch_PrimitiveRestartIndex;
+            // Extension: 3.1
+            DrawArraysInstanced = Switch_DrawArraysInstanced;
+            DrawElementsInstanced = Switch_DrawElementsInstanced;
+            TexBuffer = Switch_TexBuffer;
+            PrimitiveRestartIndex = Switch_PrimitiveRestartIndex;
 
-        // Legacy
-        EnableClientState = Switch_EnableClientState;
-        DisableClientState = Switch_DisableClientState;
-        VertexPointer = Switch_VertexPointer;
-        NormalPointer = Switch_NormalPointer;
-        ColorPointer = Switch_ColorPointer;
-        TexCoordPointer = Switch_TexCoordPointer;
-
-        TexEnvi = Switch_TexEnvi;
-
-        MatrixMode = Switch_MatrixMode;
-        LoadIdentity = Switch_LoadIdentity;
-        Ortho = Switch_Ortho;
-
-        Color3d = Switch_Color3d;
-
-      }
+            // Legacy
+            EnableClientState = Switch_EnableClientState;
+            DisableClientState = Switch_DisableClientState;
+            VertexPointer = Switch_VertexPointer;
+            NormalPointer = Switch_NormalPointer;
+            ColorPointer = Switch_ColorPointer;
+            TexCoordPointer = Switch_TexCoordPointer;
+            TexEnvi = Switch_TexEnvi;
+            MatrixMode = Switch_MatrixMode;
+            LoadIdentity = Switch_LoadIdentity;
+            Ortho = Switch_Ortho;
+            Color3d = Switch_Color3d;
+        }
     };
 
     InitializeVariables g_initVariables;
-  }
-
-  namespace sys
-  {
-    namespace
-    {
-      void ClearExtensionVariables()
-      {
-      }
-
-      struct MapEntry
-      {
-        const char *extName;
-        bool *extVariable;
-      };
-
-      struct MapCompare
-      {
-        MapCompare(const char *test_) : test(test_) {}
-        bool operator()(const MapEntry &other) { return strcmp(test, other.extName) == 0; }
-        const char *test;
-      };
-
-      struct ClearEntry
-      {
-        void operator()(MapEntry &entry) { *(entry.extVariable) = false;}
-      };
-
-      MapEntry g_mappingTable[1] =
-      {
-      };
-
-      void LoadExtByName(const char *extensionName)
-      {
-        MapEntry *tableEnd = &g_mappingTable[0];
-        MapEntry *entry = std::find_if(&g_mappingTable[0], tableEnd, MapCompare(extensionName));
-
-        if(entry != tableEnd)
-            *(entry->extVariable) = true;
-      }
-
-      void ProcExtsFromExtList()
-      {
-        GLint iLoop;
-        GLint iNumExtensions = 0;
-        GetIntegerv(NUM_EXTENSIONS, &iNumExtensions);
-
-        for(iLoop = 0; iLoop < iNumExtensions; iLoop++)
-        {
-            const char *strExtensionName = (const char *)GetStringi(EXTENSIONS, iLoop);
-            LoadExtByName(strExtensionName);
-        }
-      }
-    }
-    void CheckExtensions()
-    {
-      ClearExtensionVariables();
-      std::for_each(&g_mappingTable[0], &g_mappingTable[0], ClearEntry());
-
-      ProcExtsFromExtList();
-    }
-
-  }
 }
 
 #endif
diff --git a/modules/core/src/gl_core_3_1.hpp b/modules/core/src/gl_core_3_1.hpp
index 711ebe9ab..50dbee66c 100644
--- a/modules/core/src/gl_core_3_1.hpp
+++ b/modules/core/src/gl_core_3_1.hpp
@@ -37,7 +37,7 @@
     #else
         #define APIENTRY
     #endif
-#endif /*APIENTRY*/
+#endif // APIENTRY
 
 #ifndef CODEGEN_FUNCPTR
     #define CODEGEN_REMOVE_FUNCPTR
@@ -46,1297 +46,1286 @@
     #else
         #define CODEGEN_FUNCPTR
     #endif
-#endif /*CODEGEN_FUNCPTR*/
-
-#ifndef GLAPI
-    #define GLAPI extern
-#endif
-
+#endif // CODEGEN_FUNCPTR
 
 #ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
 #define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
-
-  typedef unsigned int GLenum;
-  typedef unsigned char GLboolean;
-  typedef unsigned int GLbitfield;
-  typedef signed char GLbyte;
-  typedef short GLshort;
-  typedef int GLint;
-  typedef int GLsizei;
-  typedef unsigned char GLubyte;
-  typedef unsigned short GLushort;
-  typedef unsigned int GLuint;
-  typedef float GLfloat;
-  typedef float GLclampf;
-  typedef double GLdouble;
-  typedef double GLclampd;
-  #define GLvoid void
-
-#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/
+    typedef unsigned int GLenum;
+    typedef unsigned char GLboolean;
+    typedef unsigned int GLbitfield;
+    typedef signed char GLbyte;
+    typedef short GLshort;
+    typedef int GLint;
+    typedef int GLsizei;
+    typedef unsigned char GLubyte;
+    typedef unsigned short GLushort;
+    typedef unsigned int GLuint;
+    typedef float GLfloat;
+    typedef float GLclampf;
+    typedef double GLdouble;
+    typedef double GLclampd;
+    #define GLvoid void
+#endif // GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS
 
 #include <stddef.h>
+
 #ifndef GL_VERSION_2_0
-  /* GL type for program/shader text */
-  typedef char GLchar;
+    // GL type for program/shader text
+    typedef char GLchar;
 #endif
+
 #ifndef GL_VERSION_1_5
-  /* GL types for handling large vertex buffer objects */
-  typedef ptrdiff_t GLintptr;
-  typedef ptrdiff_t GLsizeiptr;
+    // GL types for handling large vertex buffer objects
+    typedef ptrdiff_t GLintptr;
+    typedef ptrdiff_t GLsizeiptr;
 #endif
+
 #ifndef GL_ARB_vertex_buffer_object
-  /* GL types for handling large vertex buffer objects */
-  typedef ptrdiff_t GLintptrARB;
-  typedef ptrdiff_t GLsizeiptrARB;
+    // GL types for handling large vertex buffer objects
+    typedef ptrdiff_t GLintptrARB;
+    typedef ptrdiff_t GLsizeiptrARB;
 #endif
+
 #ifndef GL_ARB_shader_objects
-  /* GL types for program/shader text and shader object handles */
-  typedef char GLcharARB;
-  typedef unsigned int GLhandleARB;
+    // GL types for program/shader text and shader object handles
+    typedef char GLcharARB;
+    typedef unsigned int GLhandleARB;
 #endif
-/* GL type for "half" precision (s10e5) float data in host memory */
+
+// GL type for "half" precision (s10e5) float data in host memory
 #ifndef GL_ARB_half_float_pixel
-  typedef unsigned short GLhalfARB;
+    typedef unsigned short GLhalfARB;
 #endif
 #ifndef GL_NV_half_float
-  typedef unsigned short GLhalfNV;
+    typedef unsigned short GLhalfNV;
 #endif
+
 #ifndef GLEXT_64_TYPES_DEFINED
-  /* This code block is duplicated in glxext.h, so must be protected */
-  #define GLEXT_64_TYPES_DEFINED
-  /* Define int32_t, int64_t, and uint64_t types for UST/MSC */
-  /* (as used in the GL_EXT_timer_query extension). */
-  #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-    #include <inttypes.h>
-  #elif defined(__sun__) || defined(__digital__)
-    #include <inttypes.h>
-    #if defined(__STDC__)
-      #if defined(__arch64__) || defined(_LP64)
-        typedef long int int64_t;
-        typedef unsigned long int uint64_t;
-        #else
+    // This code block is duplicated in glxext.h, so must be protected
+    #define GLEXT_64_TYPES_DEFINED
+
+    // Define int32_t, int64_t, and uint64_t types for UST/MSC
+    // (as used in the GL_EXT_timer_query extension)
+    #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+        #include <inttypes.h>
+    #elif defined(__sun__) || defined(__digital__)
+        #include <inttypes.h>
+        #if defined(__STDC__)
+            #if defined(__arch64__) || defined(_LP64)
+                typedef long int int64_t;
+                typedef unsigned long int uint64_t;
+            #else
+                typedef long long int int64_t;
+                typedef unsigned long long int uint64_t;
+            #endif // __arch64__
+        #endif // __STDC__
+    #elif defined( __VMS ) || defined(__sgi)
+        #include <inttypes.h>
+    #elif defined(__SCO__) || defined(__USLC__)
+        #include <stdint.h>
+    #elif defined(__UNIXOS2__) || defined(__SOL64__)
+        typedef long int int32_t;
         typedef long long int int64_t;
         typedef unsigned long long int uint64_t;
-      #endif /* __arch64__ */
-    #endif /* __STDC__ */
-  #elif defined( __VMS ) || defined(__sgi)
-    #include <inttypes.h>
-  #elif defined(__SCO__) || defined(__USLC__)
-    #include <stdint.h>
-  #elif defined(__UNIXOS2__) || defined(__SOL64__)
-    typedef long int int32_t;
-    typedef long long int int64_t;
-    typedef unsigned long long int uint64_t;
-  #elif defined(_WIN32) && defined(__GNUC__)
-    #include <stdint.h>
-  #elif defined(_WIN32)
-    typedef __int32 int32_t;
-    typedef __int64 int64_t;
-    typedef unsigned __int64 uint64_t;
+    #elif defined(_WIN32) && defined(__GNUC__)
+        #include <stdint.h>
+    #elif defined(_WIN32)
+        typedef __int32 int32_t;
+        typedef __int64 int64_t;
+        typedef unsigned __int64 uint64_t;
     #else
-    /* Fallback if nothing above works */
-    #include <inttypes.h>
-  #endif
+        // Fallback if nothing above works
+        #include <inttypes.h>
+    #endif
 #endif
+
 #ifndef GL_EXT_timer_query
-  typedef int64_t GLint64EXT;
-  typedef uint64_t GLuint64EXT;
+    typedef int64_t GLint64EXT;
+    typedef uint64_t GLuint64EXT;
 #endif
+
 #ifndef GL_ARB_sync
-  typedef int64_t GLint64;
-  typedef uint64_t GLuint64;
-  typedef struct __GLsync *GLsync;
+    typedef int64_t GLint64;
+    typedef uint64_t GLuint64;
+    typedef struct __GLsync *GLsync;
 #endif
+
 #ifndef GL_ARB_cl_event
-  /* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */
-  struct _cl_context;
-  struct _cl_event;
+    // These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event
+    struct _cl_context;
+    struct _cl_event;
 #endif
+
 #ifndef GL_ARB_debug_output
-  typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+    typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 #endif
+
 #ifndef GL_AMD_debug_output
-  typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+    typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 #endif
+
 #ifndef GL_KHR_debug
-  typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
+    typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam);
 #endif
+
 #ifndef GL_NV_vdpau_interop
-  typedef GLintptr GLvdpauSurfaceNV;
+    typedef GLintptr GLvdpauSurfaceNV;
 #endif
 
 namespace gl
 {
-  /////////////////////////
-  // Extension Variables
-  namespace exts
-  {
-  }
+    enum
+    {
+        // Version: 1.1
+        DEPTH_BUFFER_BIT                 = 0x00000100,
+        STENCIL_BUFFER_BIT               = 0x00000400,
+        COLOR_BUFFER_BIT                 = 0x00004000,
+        FALSE_                           = 0,
+        TRUE_                            = 1,
+        POINTS                           = 0x0000,
+        LINES                            = 0x0001,
+        LINE_LOOP                        = 0x0002,
+        LINE_STRIP                       = 0x0003,
+        TRIANGLES                        = 0x0004,
+        TRIANGLE_STRIP                   = 0x0005,
+        TRIANGLE_FAN                     = 0x0006,
+        QUADS                            = 0x0007,
+        NEVER                            = 0x0200,
+        LESS                             = 0x0201,
+        EQUAL                            = 0x0202,
+        LEQUAL                           = 0x0203,
+        GREATER                          = 0x0204,
+        NOTEQUAL                         = 0x0205,
+        GEQUAL                           = 0x0206,
+        ALWAYS                           = 0x0207,
+        ZERO                             = 0,
+        ONE                              = 1,
+        SRC_COLOR                        = 0x0300,
+        ONE_MINUS_SRC_COLOR              = 0x0301,
+        SRC_ALPHA                        = 0x0302,
+        ONE_MINUS_SRC_ALPHA              = 0x0303,
+        DST_ALPHA                        = 0x0304,
+        ONE_MINUS_DST_ALPHA              = 0x0305,
+        DST_COLOR                        = 0x0306,
+        ONE_MINUS_DST_COLOR              = 0x0307,
+        SRC_ALPHA_SATURATE               = 0x0308,
+        NONE                             = 0,
+        FRONT_LEFT                       = 0x0400,
+        FRONT_RIGHT                      = 0x0401,
+        BACK_LEFT                        = 0x0402,
+        BACK_RIGHT                       = 0x0403,
+        FRONT                            = 0x0404,
+        BACK                             = 0x0405,
+        LEFT                             = 0x0406,
+        RIGHT                            = 0x0407,
+        FRONT_AND_BACK                   = 0x0408,
+        NO_ERROR_                        = 0,
+        INVALID_ENUM                     = 0x0500,
+        INVALID_VALUE                    = 0x0501,
+        INVALID_OPERATION                = 0x0502,
+        OUT_OF_MEMORY                    = 0x0505,
+        CW                               = 0x0900,
+        CCW                              = 0x0901,
+        POINT_SIZE                       = 0x0B11,
+        POINT_SIZE_RANGE                 = 0x0B12,
+        POINT_SIZE_GRANULARITY           = 0x0B13,
+        LINE_SMOOTH                      = 0x0B20,
+        LINE_WIDTH                       = 0x0B21,
+        LINE_WIDTH_RANGE                 = 0x0B22,
+        LINE_WIDTH_GRANULARITY           = 0x0B23,
+        POLYGON_MODE                     = 0x0B40,
+        POLYGON_SMOOTH                   = 0x0B41,
+        CULL_FACE                        = 0x0B44,
+        CULL_FACE_MODE                   = 0x0B45,
+        FRONT_FACE                       = 0x0B46,
+        DEPTH_RANGE                      = 0x0B70,
+        DEPTH_TEST                       = 0x0B71,
+        DEPTH_WRITEMASK                  = 0x0B72,
+        DEPTH_CLEAR_VALUE                = 0x0B73,
+        DEPTH_FUNC                       = 0x0B74,
+        STENCIL_TEST                     = 0x0B90,
+        STENCIL_CLEAR_VALUE              = 0x0B91,
+        STENCIL_FUNC                     = 0x0B92,
+        STENCIL_VALUE_MASK               = 0x0B93,
+        STENCIL_FAIL                     = 0x0B94,
+        STENCIL_PASS_DEPTH_FAIL          = 0x0B95,
+        STENCIL_PASS_DEPTH_PASS          = 0x0B96,
+        STENCIL_REF                      = 0x0B97,
+        STENCIL_WRITEMASK                = 0x0B98,
+        VIEWPORT                         = 0x0BA2,
+        DITHER                           = 0x0BD0,
+        BLEND_DST                        = 0x0BE0,
+        BLEND_SRC                        = 0x0BE1,
+        BLEND                            = 0x0BE2,
+        LOGIC_OP_MODE                    = 0x0BF0,
+        COLOR_LOGIC_OP                   = 0x0BF2,
+        DRAW_BUFFER                      = 0x0C01,
+        READ_BUFFER                      = 0x0C02,
+        SCISSOR_BOX                      = 0x0C10,
+        SCISSOR_TEST                     = 0x0C11,
+        COLOR_CLEAR_VALUE                = 0x0C22,
+        COLOR_WRITEMASK                  = 0x0C23,
+        DOUBLEBUFFER                     = 0x0C32,
+        STEREO                           = 0x0C33,
+        LINE_SMOOTH_HINT                 = 0x0C52,
+        POLYGON_SMOOTH_HINT              = 0x0C53,
+        UNPACK_SWAP_BYTES                = 0x0CF0,
+        UNPACK_LSB_FIRST                 = 0x0CF1,
+        UNPACK_ROW_LENGTH                = 0x0CF2,
+        UNPACK_SKIP_ROWS                 = 0x0CF3,
+        UNPACK_SKIP_PIXELS               = 0x0CF4,
+        UNPACK_ALIGNMENT                 = 0x0CF5,
+        PACK_SWAP_BYTES                  = 0x0D00,
+        PACK_LSB_FIRST                   = 0x0D01,
+        PACK_ROW_LENGTH                  = 0x0D02,
+        PACK_SKIP_ROWS                   = 0x0D03,
+        PACK_SKIP_PIXELS                 = 0x0D04,
+        PACK_ALIGNMENT                   = 0x0D05,
+        MAX_TEXTURE_SIZE                 = 0x0D33,
+        MAX_VIEWPORT_DIMS                = 0x0D3A,
+        SUBPIXEL_BITS                    = 0x0D50,
+        TEXTURE_1D                       = 0x0DE0,
+        TEXTURE_2D                       = 0x0DE1,
+        POLYGON_OFFSET_UNITS             = 0x2A00,
+        POLYGON_OFFSET_POINT             = 0x2A01,
+        POLYGON_OFFSET_LINE              = 0x2A02,
+        POLYGON_OFFSET_FILL              = 0x8037,
+        POLYGON_OFFSET_FACTOR            = 0x8038,
+        TEXTURE_BINDING_1D               = 0x8068,
+        TEXTURE_BINDING_2D               = 0x8069,
+        TEXTURE_WIDTH                    = 0x1000,
+        TEXTURE_HEIGHT                   = 0x1001,
+        TEXTURE_INTERNAL_FORMAT          = 0x1003,
+        TEXTURE_BORDER_COLOR             = 0x1004,
+        TEXTURE_RED_SIZE                 = 0x805C,
+        TEXTURE_GREEN_SIZE               = 0x805D,
+        TEXTURE_BLUE_SIZE                = 0x805E,
+        TEXTURE_ALPHA_SIZE               = 0x805F,
+        DONT_CARE                        = 0x1100,
+        FASTEST                          = 0x1101,
+        NICEST                           = 0x1102,
+        BYTE                             = 0x1400,
+        UNSIGNED_BYTE                    = 0x1401,
+        SHORT                            = 0x1402,
+        UNSIGNED_SHORT                   = 0x1403,
+        INT                              = 0x1404,
+        UNSIGNED_INT                     = 0x1405,
+        FLOAT                            = 0x1406,
+        DOUBLE                           = 0x140A,
+        CLEAR                            = 0x1500,
+        AND                              = 0x1501,
+        AND_REVERSE                      = 0x1502,
+        COPY                             = 0x1503,
+        AND_INVERTED                     = 0x1504,
+        NOOP                             = 0x1505,
+        XOR                              = 0x1506,
+        OR                               = 0x1507,
+        NOR                              = 0x1508,
+        EQUIV                            = 0x1509,
+        INVERT                           = 0x150A,
+        OR_REVERSE                       = 0x150B,
+        COPY_INVERTED                    = 0x150C,
+        OR_INVERTED                      = 0x150D,
+        NAND                             = 0x150E,
+        SET                              = 0x150F,
+        TEXTURE                          = 0x1702,
+        COLOR                            = 0x1800,
+        DEPTH                            = 0x1801,
+        STENCIL                          = 0x1802,
+        STENCIL_INDEX                    = 0x1901,
+        DEPTH_COMPONENT                  = 0x1902,
+        RED                              = 0x1903,
+        GREEN                            = 0x1904,
+        BLUE                             = 0x1905,
+        ALPHA                            = 0x1906,
+        RGB                              = 0x1907,
+        RGBA                             = 0x1908,
+        POINT                            = 0x1B00,
+        LINE                             = 0x1B01,
+        FILL                             = 0x1B02,
+        KEEP                             = 0x1E00,
+        REPLACE                          = 0x1E01,
+        INCR                             = 0x1E02,
+        DECR                             = 0x1E03,
+        VENDOR                           = 0x1F00,
+        RENDERER                         = 0x1F01,
+        VERSION_                         = 0x1F02,
+        EXTENSIONS                       = 0x1F03,
+        NEAREST                          = 0x2600,
+        LINEAR                           = 0x2601,
+        NEAREST_MIPMAP_NEAREST           = 0x2700,
+        LINEAR_MIPMAP_NEAREST            = 0x2701,
+        NEAREST_MIPMAP_LINEAR            = 0x2702,
+        LINEAR_MIPMAP_LINEAR             = 0x2703,
+        TEXTURE_MAG_FILTER               = 0x2800,
+        TEXTURE_MIN_FILTER               = 0x2801,
+        TEXTURE_WRAP_S                   = 0x2802,
+        TEXTURE_WRAP_T                   = 0x2803,
+        PROXY_TEXTURE_1D                 = 0x8063,
+        PROXY_TEXTURE_2D                 = 0x8064,
+        REPEAT                           = 0x2901,
+        R3_G3_B2                         = 0x2A10,
+        RGB4                             = 0x804F,
+        RGB5                             = 0x8050,
+        RGB8                             = 0x8051,
+        RGB10                            = 0x8052,
+        RGB12                            = 0x8053,
+        RGB16                            = 0x8054,
+        RGBA2                            = 0x8055,
+        RGBA4                            = 0x8056,
+        RGB5_A1                          = 0x8057,
+        RGBA8                            = 0x8058,
+        RGB10_A2                         = 0x8059,
+        RGBA12                           = 0x805A,
+        RGBA16                           = 0x805B,
 
-  enum
-  {
-    // Version: 1.1
-    DEPTH_BUFFER_BIT                 = 0x00000100,
-    STENCIL_BUFFER_BIT               = 0x00000400,
-    COLOR_BUFFER_BIT                 = 0x00004000,
-    FALSE_                           = 0,
-    TRUE_                            = 1,
-    POINTS                           = 0x0000,
-    LINES                            = 0x0001,
-    LINE_LOOP                        = 0x0002,
-    LINE_STRIP                       = 0x0003,
-    TRIANGLES                        = 0x0004,
-    TRIANGLE_STRIP                   = 0x0005,
-    TRIANGLE_FAN                     = 0x0006,
-    QUADS                            = 0x0007,
-    NEVER                            = 0x0200,
-    LESS                             = 0x0201,
-    EQUAL                            = 0x0202,
-    LEQUAL                           = 0x0203,
-    GREATER                          = 0x0204,
-    NOTEQUAL                         = 0x0205,
-    GEQUAL                           = 0x0206,
-    ALWAYS                           = 0x0207,
-    ZERO                             = 0,
-    ONE                              = 1,
-    SRC_COLOR                        = 0x0300,
-    ONE_MINUS_SRC_COLOR              = 0x0301,
-    SRC_ALPHA                        = 0x0302,
-    ONE_MINUS_SRC_ALPHA              = 0x0303,
-    DST_ALPHA                        = 0x0304,
-    ONE_MINUS_DST_ALPHA              = 0x0305,
-    DST_COLOR                        = 0x0306,
-    ONE_MINUS_DST_COLOR              = 0x0307,
-    SRC_ALPHA_SATURATE               = 0x0308,
-    NONE                             = 0,
-    FRONT_LEFT                       = 0x0400,
-    FRONT_RIGHT                      = 0x0401,
-    BACK_LEFT                        = 0x0402,
-    BACK_RIGHT                       = 0x0403,
-    FRONT                            = 0x0404,
-    BACK                             = 0x0405,
-    LEFT                             = 0x0406,
-    RIGHT                            = 0x0407,
-    FRONT_AND_BACK                   = 0x0408,
-    NO_ERROR_                        = 0,
-    INVALID_ENUM                     = 0x0500,
-    INVALID_VALUE                    = 0x0501,
-    INVALID_OPERATION                = 0x0502,
-    OUT_OF_MEMORY                    = 0x0505,
-    CW                               = 0x0900,
-    CCW                              = 0x0901,
-    POINT_SIZE                       = 0x0B11,
-    POINT_SIZE_RANGE                 = 0x0B12,
-    POINT_SIZE_GRANULARITY           = 0x0B13,
-    LINE_SMOOTH                      = 0x0B20,
-    LINE_WIDTH                       = 0x0B21,
-    LINE_WIDTH_RANGE                 = 0x0B22,
-    LINE_WIDTH_GRANULARITY           = 0x0B23,
-    POLYGON_MODE                     = 0x0B40,
-    POLYGON_SMOOTH                   = 0x0B41,
-    CULL_FACE                        = 0x0B44,
-    CULL_FACE_MODE                   = 0x0B45,
-    FRONT_FACE                       = 0x0B46,
-    DEPTH_RANGE                      = 0x0B70,
-    DEPTH_TEST                       = 0x0B71,
-    DEPTH_WRITEMASK                  = 0x0B72,
-    DEPTH_CLEAR_VALUE                = 0x0B73,
-    DEPTH_FUNC                       = 0x0B74,
-    STENCIL_TEST                     = 0x0B90,
-    STENCIL_CLEAR_VALUE              = 0x0B91,
-    STENCIL_FUNC                     = 0x0B92,
-    STENCIL_VALUE_MASK               = 0x0B93,
-    STENCIL_FAIL                     = 0x0B94,
-    STENCIL_PASS_DEPTH_FAIL          = 0x0B95,
-    STENCIL_PASS_DEPTH_PASS          = 0x0B96,
-    STENCIL_REF                      = 0x0B97,
-    STENCIL_WRITEMASK                = 0x0B98,
-    VIEWPORT                         = 0x0BA2,
-    DITHER                           = 0x0BD0,
-    BLEND_DST                        = 0x0BE0,
-    BLEND_SRC                        = 0x0BE1,
-    BLEND                            = 0x0BE2,
-    LOGIC_OP_MODE                    = 0x0BF0,
-    COLOR_LOGIC_OP                   = 0x0BF2,
-    DRAW_BUFFER                      = 0x0C01,
-    READ_BUFFER                      = 0x0C02,
-    SCISSOR_BOX                      = 0x0C10,
-    SCISSOR_TEST                     = 0x0C11,
-    COLOR_CLEAR_VALUE                = 0x0C22,
-    COLOR_WRITEMASK                  = 0x0C23,
-    DOUBLEBUFFER                     = 0x0C32,
-    STEREO                           = 0x0C33,
-    LINE_SMOOTH_HINT                 = 0x0C52,
-    POLYGON_SMOOTH_HINT              = 0x0C53,
-    UNPACK_SWAP_BYTES                = 0x0CF0,
-    UNPACK_LSB_FIRST                 = 0x0CF1,
-    UNPACK_ROW_LENGTH                = 0x0CF2,
-    UNPACK_SKIP_ROWS                 = 0x0CF3,
-    UNPACK_SKIP_PIXELS               = 0x0CF4,
-    UNPACK_ALIGNMENT                 = 0x0CF5,
-    PACK_SWAP_BYTES                  = 0x0D00,
-    PACK_LSB_FIRST                   = 0x0D01,
-    PACK_ROW_LENGTH                  = 0x0D02,
-    PACK_SKIP_ROWS                   = 0x0D03,
-    PACK_SKIP_PIXELS                 = 0x0D04,
-    PACK_ALIGNMENT                   = 0x0D05,
-    MAX_TEXTURE_SIZE                 = 0x0D33,
-    MAX_VIEWPORT_DIMS                = 0x0D3A,
-    SUBPIXEL_BITS                    = 0x0D50,
-    TEXTURE_1D                       = 0x0DE0,
-    TEXTURE_2D                       = 0x0DE1,
-    POLYGON_OFFSET_UNITS             = 0x2A00,
-    POLYGON_OFFSET_POINT             = 0x2A01,
-    POLYGON_OFFSET_LINE              = 0x2A02,
-    POLYGON_OFFSET_FILL              = 0x8037,
-    POLYGON_OFFSET_FACTOR            = 0x8038,
-    TEXTURE_BINDING_1D               = 0x8068,
-    TEXTURE_BINDING_2D               = 0x8069,
-    TEXTURE_WIDTH                    = 0x1000,
-    TEXTURE_HEIGHT                   = 0x1001,
-    TEXTURE_INTERNAL_FORMAT          = 0x1003,
-    TEXTURE_BORDER_COLOR             = 0x1004,
-    TEXTURE_RED_SIZE                 = 0x805C,
-    TEXTURE_GREEN_SIZE               = 0x805D,
-    TEXTURE_BLUE_SIZE                = 0x805E,
-    TEXTURE_ALPHA_SIZE               = 0x805F,
-    DONT_CARE                        = 0x1100,
-    FASTEST                          = 0x1101,
-    NICEST                           = 0x1102,
-    BYTE                             = 0x1400,
-    UNSIGNED_BYTE                    = 0x1401,
-    SHORT                            = 0x1402,
-    UNSIGNED_SHORT                   = 0x1403,
-    INT                              = 0x1404,
-    UNSIGNED_INT                     = 0x1405,
-    FLOAT                            = 0x1406,
-    DOUBLE                           = 0x140A,
-    CLEAR                            = 0x1500,
-    AND                              = 0x1501,
-    AND_REVERSE                      = 0x1502,
-    COPY                             = 0x1503,
-    AND_INVERTED                     = 0x1504,
-    NOOP                             = 0x1505,
-    XOR                              = 0x1506,
-    OR                               = 0x1507,
-    NOR                              = 0x1508,
-    EQUIV                            = 0x1509,
-    INVERT                           = 0x150A,
-    OR_REVERSE                       = 0x150B,
-    COPY_INVERTED                    = 0x150C,
-    OR_INVERTED                      = 0x150D,
-    NAND                             = 0x150E,
-    SET                              = 0x150F,
-    TEXTURE                          = 0x1702,
-    COLOR                            = 0x1800,
-    DEPTH                            = 0x1801,
-    STENCIL                          = 0x1802,
-    STENCIL_INDEX                    = 0x1901,
-    DEPTH_COMPONENT                  = 0x1902,
-    RED                              = 0x1903,
-    GREEN                            = 0x1904,
-    BLUE                             = 0x1905,
-    ALPHA                            = 0x1906,
-    RGB                              = 0x1907,
-    RGBA                             = 0x1908,
-    POINT                            = 0x1B00,
-    LINE                             = 0x1B01,
-    FILL                             = 0x1B02,
-    KEEP                             = 0x1E00,
-    REPLACE                          = 0x1E01,
-    INCR                             = 0x1E02,
-    DECR                             = 0x1E03,
-    VENDOR                           = 0x1F00,
-    RENDERER                         = 0x1F01,
-    VERSION_                         = 0x1F02,
-    EXTENSIONS                       = 0x1F03,
-    NEAREST                          = 0x2600,
-    LINEAR                           = 0x2601,
-    NEAREST_MIPMAP_NEAREST           = 0x2700,
-    LINEAR_MIPMAP_NEAREST            = 0x2701,
-    NEAREST_MIPMAP_LINEAR            = 0x2702,
-    LINEAR_MIPMAP_LINEAR             = 0x2703,
-    TEXTURE_MAG_FILTER               = 0x2800,
-    TEXTURE_MIN_FILTER               = 0x2801,
-    TEXTURE_WRAP_S                   = 0x2802,
-    TEXTURE_WRAP_T                   = 0x2803,
-    PROXY_TEXTURE_1D                 = 0x8063,
-    PROXY_TEXTURE_2D                 = 0x8064,
-    REPEAT                           = 0x2901,
-    R3_G3_B2                         = 0x2A10,
-    RGB4                             = 0x804F,
-    RGB5                             = 0x8050,
-    RGB8                             = 0x8051,
-    RGB10                            = 0x8052,
-    RGB12                            = 0x8053,
-    RGB16                            = 0x8054,
-    RGBA2                            = 0x8055,
-    RGBA4                            = 0x8056,
-    RGB5_A1                          = 0x8057,
-    RGBA8                            = 0x8058,
-    RGB10_A2                         = 0x8059,
-    RGBA12                           = 0x805A,
-    RGBA16                           = 0x805B,
+        // Core Extension: ARB_imaging
+        CONSTANT_COLOR                   = 0x8001,
+        ONE_MINUS_CONSTANT_COLOR         = 0x8002,
+        CONSTANT_ALPHA                   = 0x8003,
+        ONE_MINUS_CONSTANT_ALPHA         = 0x8004,
+        BLEND_COLOR                      = 0x8005,
+        FUNC_ADD                         = 0x8006,
+        MIN                              = 0x8007,
+        MAX                              = 0x8008,
+        BLEND_EQUATION                   = 0x8009,
+        FUNC_SUBTRACT                    = 0x800A,
+        FUNC_REVERSE_SUBTRACT            = 0x800B,
+        CONVOLUTION_1D                   = 0x8010,
+        CONVOLUTION_2D                   = 0x8011,
+        SEPARABLE_2D                     = 0x8012,
+        CONVOLUTION_BORDER_MODE          = 0x8013,
+        CONVOLUTION_FILTER_SCALE         = 0x8014,
+        CONVOLUTION_FILTER_BIAS          = 0x8015,
+        REDUCE                           = 0x8016,
+        CONVOLUTION_FORMAT               = 0x8017,
+        CONVOLUTION_WIDTH                = 0x8018,
+        CONVOLUTION_HEIGHT               = 0x8019,
+        MAX_CONVOLUTION_WIDTH            = 0x801A,
+        MAX_CONVOLUTION_HEIGHT           = 0x801B,
+        POST_CONVOLUTION_RED_SCALE       = 0x801C,
+        POST_CONVOLUTION_GREEN_SCALE     = 0x801D,
+        POST_CONVOLUTION_BLUE_SCALE      = 0x801E,
+        POST_CONVOLUTION_ALPHA_SCALE     = 0x801F,
+        POST_CONVOLUTION_RED_BIAS        = 0x8020,
+        POST_CONVOLUTION_GREEN_BIAS      = 0x8021,
+        POST_CONVOLUTION_BLUE_BIAS       = 0x8022,
+        POST_CONVOLUTION_ALPHA_BIAS      = 0x8023,
+        HISTOGRAM                        = 0x8024,
+        PROXY_HISTOGRAM                  = 0x8025,
+        HISTOGRAM_WIDTH                  = 0x8026,
+        HISTOGRAM_FORMAT                 = 0x8027,
+        HISTOGRAM_RED_SIZE               = 0x8028,
+        HISTOGRAM_GREEN_SIZE             = 0x8029,
+        HISTOGRAM_BLUE_SIZE              = 0x802A,
+        HISTOGRAM_ALPHA_SIZE             = 0x802B,
+        HISTOGRAM_LUMINANCE_SIZE         = 0x802C,
+        HISTOGRAM_SINK                   = 0x802D,
+        MINMAX                           = 0x802E,
+        MINMAX_FORMAT                    = 0x802F,
+        MINMAX_SINK                      = 0x8030,
+        TABLE_TOO_LARGE                  = 0x8031,
+        COLOR_MATRIX                     = 0x80B1,
+        COLOR_MATRIX_STACK_DEPTH         = 0x80B2,
+        MAX_COLOR_MATRIX_STACK_DEPTH     = 0x80B3,
+        POST_COLOR_MATRIX_RED_SCALE      = 0x80B4,
+        POST_COLOR_MATRIX_GREEN_SCALE    = 0x80B5,
+        POST_COLOR_MATRIX_BLUE_SCALE     = 0x80B6,
+        POST_COLOR_MATRIX_ALPHA_SCALE    = 0x80B7,
+        POST_COLOR_MATRIX_RED_BIAS       = 0x80B8,
+        POST_COLOR_MATRIX_GREEN_BIAS     = 0x80B9,
+        POST_COLOR_MATRIX_BLUE_BIAS      = 0x80BA,
+        POST_COLOR_MATRIX_ALPHA_BIAS     = 0x80BB,
+        COLOR_TABLE                      = 0x80D0,
+        POST_CONVOLUTION_COLOR_TABLE     = 0x80D1,
+        POST_COLOR_MATRIX_COLOR_TABLE    = 0x80D2,
+        PROXY_COLOR_TABLE                = 0x80D3,
+        PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+        PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+        COLOR_TABLE_SCALE                = 0x80D6,
+        COLOR_TABLE_BIAS                 = 0x80D7,
+        COLOR_TABLE_FORMAT               = 0x80D8,
+        COLOR_TABLE_WIDTH                = 0x80D9,
+        COLOR_TABLE_RED_SIZE             = 0x80DA,
+        COLOR_TABLE_GREEN_SIZE           = 0x80DB,
+        COLOR_TABLE_BLUE_SIZE            = 0x80DC,
+        COLOR_TABLE_ALPHA_SIZE           = 0x80DD,
+        COLOR_TABLE_LUMINANCE_SIZE       = 0x80DE,
+        COLOR_TABLE_INTENSITY_SIZE       = 0x80DF,
+        CONSTANT_BORDER                  = 0x8151,
+        REPLICATE_BORDER                 = 0x8153,
+        CONVOLUTION_BORDER_COLOR         = 0x8154,
 
-    // Core Extension: ARB_imaging
-    CONSTANT_COLOR                   = 0x8001,
-    ONE_MINUS_CONSTANT_COLOR         = 0x8002,
-    CONSTANT_ALPHA                   = 0x8003,
-    ONE_MINUS_CONSTANT_ALPHA         = 0x8004,
-    BLEND_COLOR                      = 0x8005,
-    FUNC_ADD                         = 0x8006,
-    MIN                              = 0x8007,
-    MAX                              = 0x8008,
-    BLEND_EQUATION                   = 0x8009,
-    FUNC_SUBTRACT                    = 0x800A,
-    FUNC_REVERSE_SUBTRACT            = 0x800B,
-    CONVOLUTION_1D                   = 0x8010,
-    CONVOLUTION_2D                   = 0x8011,
-    SEPARABLE_2D                     = 0x8012,
-    CONVOLUTION_BORDER_MODE          = 0x8013,
-    CONVOLUTION_FILTER_SCALE         = 0x8014,
-    CONVOLUTION_FILTER_BIAS          = 0x8015,
-    REDUCE                           = 0x8016,
-    CONVOLUTION_FORMAT               = 0x8017,
-    CONVOLUTION_WIDTH                = 0x8018,
-    CONVOLUTION_HEIGHT               = 0x8019,
-    MAX_CONVOLUTION_WIDTH            = 0x801A,
-    MAX_CONVOLUTION_HEIGHT           = 0x801B,
-    POST_CONVOLUTION_RED_SCALE       = 0x801C,
-    POST_CONVOLUTION_GREEN_SCALE     = 0x801D,
-    POST_CONVOLUTION_BLUE_SCALE      = 0x801E,
-    POST_CONVOLUTION_ALPHA_SCALE     = 0x801F,
-    POST_CONVOLUTION_RED_BIAS        = 0x8020,
-    POST_CONVOLUTION_GREEN_BIAS      = 0x8021,
-    POST_CONVOLUTION_BLUE_BIAS       = 0x8022,
-    POST_CONVOLUTION_ALPHA_BIAS      = 0x8023,
-    HISTOGRAM                        = 0x8024,
-    PROXY_HISTOGRAM                  = 0x8025,
-    HISTOGRAM_WIDTH                  = 0x8026,
-    HISTOGRAM_FORMAT                 = 0x8027,
-    HISTOGRAM_RED_SIZE               = 0x8028,
-    HISTOGRAM_GREEN_SIZE             = 0x8029,
-    HISTOGRAM_BLUE_SIZE              = 0x802A,
-    HISTOGRAM_ALPHA_SIZE             = 0x802B,
-    HISTOGRAM_LUMINANCE_SIZE         = 0x802C,
-    HISTOGRAM_SINK                   = 0x802D,
-    MINMAX                           = 0x802E,
-    MINMAX_FORMAT                    = 0x802F,
-    MINMAX_SINK                      = 0x8030,
-    TABLE_TOO_LARGE                  = 0x8031,
-    COLOR_MATRIX                     = 0x80B1,
-    COLOR_MATRIX_STACK_DEPTH         = 0x80B2,
-    MAX_COLOR_MATRIX_STACK_DEPTH     = 0x80B3,
-    POST_COLOR_MATRIX_RED_SCALE      = 0x80B4,
-    POST_COLOR_MATRIX_GREEN_SCALE    = 0x80B5,
-    POST_COLOR_MATRIX_BLUE_SCALE     = 0x80B6,
-    POST_COLOR_MATRIX_ALPHA_SCALE    = 0x80B7,
-    POST_COLOR_MATRIX_RED_BIAS       = 0x80B8,
-    POST_COLOR_MATRIX_GREEN_BIAS     = 0x80B9,
-    POST_COLOR_MATRIX_BLUE_BIAS      = 0x80BA,
-    POST_COLOR_MATRIX_ALPHA_BIAS     = 0x80BB,
-    COLOR_TABLE                      = 0x80D0,
-    POST_CONVOLUTION_COLOR_TABLE     = 0x80D1,
-    POST_COLOR_MATRIX_COLOR_TABLE    = 0x80D2,
-    PROXY_COLOR_TABLE                = 0x80D3,
-    PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
-    PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
-    COLOR_TABLE_SCALE                = 0x80D6,
-    COLOR_TABLE_BIAS                 = 0x80D7,
-    COLOR_TABLE_FORMAT               = 0x80D8,
-    COLOR_TABLE_WIDTH                = 0x80D9,
-    COLOR_TABLE_RED_SIZE             = 0x80DA,
-    COLOR_TABLE_GREEN_SIZE           = 0x80DB,
-    COLOR_TABLE_BLUE_SIZE            = 0x80DC,
-    COLOR_TABLE_ALPHA_SIZE           = 0x80DD,
-    COLOR_TABLE_LUMINANCE_SIZE       = 0x80DE,
-    COLOR_TABLE_INTENSITY_SIZE       = 0x80DF,
-    CONSTANT_BORDER                  = 0x8151,
-    REPLICATE_BORDER                 = 0x8153,
-    CONVOLUTION_BORDER_COLOR         = 0x8154,
+        // Version: 1.2
+        UNSIGNED_BYTE_3_3_2              = 0x8032,
+        UNSIGNED_SHORT_4_4_4_4           = 0x8033,
+        UNSIGNED_SHORT_5_5_5_1           = 0x8034,
+        UNSIGNED_INT_8_8_8_8             = 0x8035,
+        UNSIGNED_INT_10_10_10_2          = 0x8036,
+        TEXTURE_BINDING_3D               = 0x806A,
+        PACK_SKIP_IMAGES                 = 0x806B,
+        PACK_IMAGE_HEIGHT                = 0x806C,
+        UNPACK_SKIP_IMAGES               = 0x806D,
+        UNPACK_IMAGE_HEIGHT              = 0x806E,
+        TEXTURE_3D                       = 0x806F,
+        PROXY_TEXTURE_3D                 = 0x8070,
+        TEXTURE_DEPTH                    = 0x8071,
+        TEXTURE_WRAP_R                   = 0x8072,
+        MAX_3D_TEXTURE_SIZE              = 0x8073,
+        UNSIGNED_BYTE_2_3_3_REV          = 0x8362,
+        UNSIGNED_SHORT_5_6_5             = 0x8363,
+        UNSIGNED_SHORT_5_6_5_REV         = 0x8364,
+        UNSIGNED_SHORT_4_4_4_4_REV       = 0x8365,
+        UNSIGNED_SHORT_1_5_5_5_REV       = 0x8366,
+        UNSIGNED_INT_8_8_8_8_REV         = 0x8367,
+        UNSIGNED_INT_2_10_10_10_REV      = 0x8368,
+        BGR                              = 0x80E0,
+        BGRA                             = 0x80E1,
+        MAX_ELEMENTS_VERTICES            = 0x80E8,
+        MAX_ELEMENTS_INDICES             = 0x80E9,
+        CLAMP_TO_EDGE                    = 0x812F,
+        TEXTURE_MIN_LOD                  = 0x813A,
+        TEXTURE_MAX_LOD                  = 0x813B,
+        TEXTURE_BASE_LEVEL               = 0x813C,
+        TEXTURE_MAX_LEVEL                = 0x813D,
+        SMOOTH_POINT_SIZE_RANGE          = 0x0B12,
+        SMOOTH_POINT_SIZE_GRANULARITY    = 0x0B13,
+        SMOOTH_LINE_WIDTH_RANGE          = 0x0B22,
+        SMOOTH_LINE_WIDTH_GRANULARITY    = 0x0B23,
+        ALIASED_LINE_WIDTH_RANGE         = 0x846E,
 
-    // Version: 1.2
-    UNSIGNED_BYTE_3_3_2              = 0x8032,
-    UNSIGNED_SHORT_4_4_4_4           = 0x8033,
-    UNSIGNED_SHORT_5_5_5_1           = 0x8034,
-    UNSIGNED_INT_8_8_8_8             = 0x8035,
-    UNSIGNED_INT_10_10_10_2          = 0x8036,
-    TEXTURE_BINDING_3D               = 0x806A,
-    PACK_SKIP_IMAGES                 = 0x806B,
-    PACK_IMAGE_HEIGHT                = 0x806C,
-    UNPACK_SKIP_IMAGES               = 0x806D,
-    UNPACK_IMAGE_HEIGHT              = 0x806E,
-    TEXTURE_3D                       = 0x806F,
-    PROXY_TEXTURE_3D                 = 0x8070,
-    TEXTURE_DEPTH                    = 0x8071,
-    TEXTURE_WRAP_R                   = 0x8072,
-    MAX_3D_TEXTURE_SIZE              = 0x8073,
-    UNSIGNED_BYTE_2_3_3_REV          = 0x8362,
-    UNSIGNED_SHORT_5_6_5             = 0x8363,
-    UNSIGNED_SHORT_5_6_5_REV         = 0x8364,
-    UNSIGNED_SHORT_4_4_4_4_REV       = 0x8365,
-    UNSIGNED_SHORT_1_5_5_5_REV       = 0x8366,
-    UNSIGNED_INT_8_8_8_8_REV         = 0x8367,
-    UNSIGNED_INT_2_10_10_10_REV      = 0x8368,
-    BGR                              = 0x80E0,
-    BGRA                             = 0x80E1,
-    MAX_ELEMENTS_VERTICES            = 0x80E8,
-    MAX_ELEMENTS_INDICES             = 0x80E9,
-    CLAMP_TO_EDGE                    = 0x812F,
-    TEXTURE_MIN_LOD                  = 0x813A,
-    TEXTURE_MAX_LOD                  = 0x813B,
-    TEXTURE_BASE_LEVEL               = 0x813C,
-    TEXTURE_MAX_LEVEL                = 0x813D,
-    SMOOTH_POINT_SIZE_RANGE          = 0x0B12,
-    SMOOTH_POINT_SIZE_GRANULARITY    = 0x0B13,
-    SMOOTH_LINE_WIDTH_RANGE          = 0x0B22,
-    SMOOTH_LINE_WIDTH_GRANULARITY    = 0x0B23,
-    ALIASED_LINE_WIDTH_RANGE         = 0x846E,
+        // Version: 1.3
+        TEXTURE0                         = 0x84C0,
+        TEXTURE1                         = 0x84C1,
+        TEXTURE2                         = 0x84C2,
+        TEXTURE3                         = 0x84C3,
+        TEXTURE4                         = 0x84C4,
+        TEXTURE5                         = 0x84C5,
+        TEXTURE6                         = 0x84C6,
+        TEXTURE7                         = 0x84C7,
+        TEXTURE8                         = 0x84C8,
+        TEXTURE9                         = 0x84C9,
+        TEXTURE10                        = 0x84CA,
+        TEXTURE11                        = 0x84CB,
+        TEXTURE12                        = 0x84CC,
+        TEXTURE13                        = 0x84CD,
+        TEXTURE14                        = 0x84CE,
+        TEXTURE15                        = 0x84CF,
+        TEXTURE16                        = 0x84D0,
+        TEXTURE17                        = 0x84D1,
+        TEXTURE18                        = 0x84D2,
+        TEXTURE19                        = 0x84D3,
+        TEXTURE20                        = 0x84D4,
+        TEXTURE21                        = 0x84D5,
+        TEXTURE22                        = 0x84D6,
+        TEXTURE23                        = 0x84D7,
+        TEXTURE24                        = 0x84D8,
+        TEXTURE25                        = 0x84D9,
+        TEXTURE26                        = 0x84DA,
+        TEXTURE27                        = 0x84DB,
+        TEXTURE28                        = 0x84DC,
+        TEXTURE29                        = 0x84DD,
+        TEXTURE30                        = 0x84DE,
+        TEXTURE31                        = 0x84DF,
+        ACTIVE_TEXTURE                   = 0x84E0,
+        MULTISAMPLE                      = 0x809D,
+        SAMPLE_ALPHA_TO_COVERAGE         = 0x809E,
+        SAMPLE_ALPHA_TO_ONE              = 0x809F,
+        SAMPLE_COVERAGE                  = 0x80A0,
+        SAMPLE_BUFFERS                   = 0x80A8,
+        SAMPLES                          = 0x80A9,
+        SAMPLE_COVERAGE_VALUE            = 0x80AA,
+        SAMPLE_COVERAGE_INVERT           = 0x80AB,
+        TEXTURE_CUBE_MAP                 = 0x8513,
+        TEXTURE_BINDING_CUBE_MAP         = 0x8514,
+        TEXTURE_CUBE_MAP_POSITIVE_X      = 0x8515,
+        TEXTURE_CUBE_MAP_NEGATIVE_X      = 0x8516,
+        TEXTURE_CUBE_MAP_POSITIVE_Y      = 0x8517,
+        TEXTURE_CUBE_MAP_NEGATIVE_Y      = 0x8518,
+        TEXTURE_CUBE_MAP_POSITIVE_Z      = 0x8519,
+        TEXTURE_CUBE_MAP_NEGATIVE_Z      = 0x851A,
+        PROXY_TEXTURE_CUBE_MAP           = 0x851B,
+        MAX_CUBE_MAP_TEXTURE_SIZE        = 0x851C,
+        COMPRESSED_RGB                   = 0x84ED,
+        COMPRESSED_RGBA                  = 0x84EE,
+        TEXTURE_COMPRESSION_HINT         = 0x84EF,
+        TEXTURE_COMPRESSED_IMAGE_SIZE    = 0x86A0,
+        TEXTURE_COMPRESSED               = 0x86A1,
+        NUM_COMPRESSED_TEXTURE_FORMATS   = 0x86A2,
+        COMPRESSED_TEXTURE_FORMATS       = 0x86A3,
+        CLAMP_TO_BORDER                  = 0x812D,
 
-    // Version: 1.3
-    TEXTURE0                         = 0x84C0,
-    TEXTURE1                         = 0x84C1,
-    TEXTURE2                         = 0x84C2,
-    TEXTURE3                         = 0x84C3,
-    TEXTURE4                         = 0x84C4,
-    TEXTURE5                         = 0x84C5,
-    TEXTURE6                         = 0x84C6,
-    TEXTURE7                         = 0x84C7,
-    TEXTURE8                         = 0x84C8,
-    TEXTURE9                         = 0x84C9,
-    TEXTURE10                        = 0x84CA,
-    TEXTURE11                        = 0x84CB,
-    TEXTURE12                        = 0x84CC,
-    TEXTURE13                        = 0x84CD,
-    TEXTURE14                        = 0x84CE,
-    TEXTURE15                        = 0x84CF,
-    TEXTURE16                        = 0x84D0,
-    TEXTURE17                        = 0x84D1,
-    TEXTURE18                        = 0x84D2,
-    TEXTURE19                        = 0x84D3,
-    TEXTURE20                        = 0x84D4,
-    TEXTURE21                        = 0x84D5,
-    TEXTURE22                        = 0x84D6,
-    TEXTURE23                        = 0x84D7,
-    TEXTURE24                        = 0x84D8,
-    TEXTURE25                        = 0x84D9,
-    TEXTURE26                        = 0x84DA,
-    TEXTURE27                        = 0x84DB,
-    TEXTURE28                        = 0x84DC,
-    TEXTURE29                        = 0x84DD,
-    TEXTURE30                        = 0x84DE,
-    TEXTURE31                        = 0x84DF,
-    ACTIVE_TEXTURE                   = 0x84E0,
-    MULTISAMPLE                      = 0x809D,
-    SAMPLE_ALPHA_TO_COVERAGE         = 0x809E,
-    SAMPLE_ALPHA_TO_ONE              = 0x809F,
-    SAMPLE_COVERAGE                  = 0x80A0,
-    SAMPLE_BUFFERS                   = 0x80A8,
-    SAMPLES                          = 0x80A9,
-    SAMPLE_COVERAGE_VALUE            = 0x80AA,
-    SAMPLE_COVERAGE_INVERT           = 0x80AB,
-    TEXTURE_CUBE_MAP                 = 0x8513,
-    TEXTURE_BINDING_CUBE_MAP         = 0x8514,
-    TEXTURE_CUBE_MAP_POSITIVE_X      = 0x8515,
-    TEXTURE_CUBE_MAP_NEGATIVE_X      = 0x8516,
-    TEXTURE_CUBE_MAP_POSITIVE_Y      = 0x8517,
-    TEXTURE_CUBE_MAP_NEGATIVE_Y      = 0x8518,
-    TEXTURE_CUBE_MAP_POSITIVE_Z      = 0x8519,
-    TEXTURE_CUBE_MAP_NEGATIVE_Z      = 0x851A,
-    PROXY_TEXTURE_CUBE_MAP           = 0x851B,
-    MAX_CUBE_MAP_TEXTURE_SIZE        = 0x851C,
-    COMPRESSED_RGB                   = 0x84ED,
-    COMPRESSED_RGBA                  = 0x84EE,
-    TEXTURE_COMPRESSION_HINT         = 0x84EF,
-    TEXTURE_COMPRESSED_IMAGE_SIZE    = 0x86A0,
-    TEXTURE_COMPRESSED               = 0x86A1,
-    NUM_COMPRESSED_TEXTURE_FORMATS   = 0x86A2,
-    COMPRESSED_TEXTURE_FORMATS       = 0x86A3,
-    CLAMP_TO_BORDER                  = 0x812D,
+        // Version: 1.4
+        BLEND_DST_RGB                    = 0x80C8,
+        BLEND_SRC_RGB                    = 0x80C9,
+        BLEND_DST_ALPHA                  = 0x80CA,
+        BLEND_SRC_ALPHA                  = 0x80CB,
+        POINT_FADE_THRESHOLD_SIZE        = 0x8128,
+        DEPTH_COMPONENT16                = 0x81A5,
+        DEPTH_COMPONENT24                = 0x81A6,
+        DEPTH_COMPONENT32                = 0x81A7,
+        MIRRORED_REPEAT                  = 0x8370,
+        MAX_TEXTURE_LOD_BIAS             = 0x84FD,
+        TEXTURE_LOD_BIAS                 = 0x8501,
+        INCR_WRAP                        = 0x8507,
+        DECR_WRAP                        = 0x8508,
+        TEXTURE_DEPTH_SIZE               = 0x884A,
+        TEXTURE_COMPARE_MODE             = 0x884C,
+        TEXTURE_COMPARE_FUNC             = 0x884D,
 
-    // Version: 1.4
-    BLEND_DST_RGB                    = 0x80C8,
-    BLEND_SRC_RGB                    = 0x80C9,
-    BLEND_DST_ALPHA                  = 0x80CA,
-    BLEND_SRC_ALPHA                  = 0x80CB,
-    POINT_FADE_THRESHOLD_SIZE        = 0x8128,
-    DEPTH_COMPONENT16                = 0x81A5,
-    DEPTH_COMPONENT24                = 0x81A6,
-    DEPTH_COMPONENT32                = 0x81A7,
-    MIRRORED_REPEAT                  = 0x8370,
-    MAX_TEXTURE_LOD_BIAS             = 0x84FD,
-    TEXTURE_LOD_BIAS                 = 0x8501,
-    INCR_WRAP                        = 0x8507,
-    DECR_WRAP                        = 0x8508,
-    TEXTURE_DEPTH_SIZE               = 0x884A,
-    TEXTURE_COMPARE_MODE             = 0x884C,
-    TEXTURE_COMPARE_FUNC             = 0x884D,
+        // Version: 1.5
+        BUFFER_SIZE                      = 0x8764,
+        BUFFER_USAGE                     = 0x8765,
+        QUERY_COUNTER_BITS               = 0x8864,
+        CURRENT_QUERY                    = 0x8865,
+        QUERY_RESULT                     = 0x8866,
+        QUERY_RESULT_AVAILABLE           = 0x8867,
+        ARRAY_BUFFER                     = 0x8892,
+        ELEMENT_ARRAY_BUFFER             = 0x8893,
+        ARRAY_BUFFER_BINDING             = 0x8894,
+        ELEMENT_ARRAY_BUFFER_BINDING     = 0x8895,
+        VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
+        READ_ONLY                        = 0x88B8,
+        WRITE_ONLY                       = 0x88B9,
+        READ_WRITE                       = 0x88BA,
+        BUFFER_ACCESS                    = 0x88BB,
+        BUFFER_MAPPED                    = 0x88BC,
+        BUFFER_MAP_POINTER               = 0x88BD,
+        STREAM_DRAW                      = 0x88E0,
+        STREAM_READ                      = 0x88E1,
+        STREAM_COPY                      = 0x88E2,
+        STATIC_DRAW                      = 0x88E4,
+        STATIC_READ                      = 0x88E5,
+        STATIC_COPY                      = 0x88E6,
+        DYNAMIC_DRAW                     = 0x88E8,
+        DYNAMIC_READ                     = 0x88E9,
+        DYNAMIC_COPY                     = 0x88EA,
+        SAMPLES_PASSED                   = 0x8914,
+        SRC1_ALPHA                       = 0x8589,
 
-    // Version: 1.5
-    BUFFER_SIZE                      = 0x8764,
-    BUFFER_USAGE                     = 0x8765,
-    QUERY_COUNTER_BITS               = 0x8864,
-    CURRENT_QUERY                    = 0x8865,
-    QUERY_RESULT                     = 0x8866,
-    QUERY_RESULT_AVAILABLE           = 0x8867,
-    ARRAY_BUFFER                     = 0x8892,
-    ELEMENT_ARRAY_BUFFER             = 0x8893,
-    ARRAY_BUFFER_BINDING             = 0x8894,
-    ELEMENT_ARRAY_BUFFER_BINDING     = 0x8895,
-    VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
-    READ_ONLY                        = 0x88B8,
-    WRITE_ONLY                       = 0x88B9,
-    READ_WRITE                       = 0x88BA,
-    BUFFER_ACCESS                    = 0x88BB,
-    BUFFER_MAPPED                    = 0x88BC,
-    BUFFER_MAP_POINTER               = 0x88BD,
-    STREAM_DRAW                      = 0x88E0,
-    STREAM_READ                      = 0x88E1,
-    STREAM_COPY                      = 0x88E2,
-    STATIC_DRAW                      = 0x88E4,
-    STATIC_READ                      = 0x88E5,
-    STATIC_COPY                      = 0x88E6,
-    DYNAMIC_DRAW                     = 0x88E8,
-    DYNAMIC_READ                     = 0x88E9,
-    DYNAMIC_COPY                     = 0x88EA,
-    SAMPLES_PASSED                   = 0x8914,
-    SRC1_ALPHA                       = 0x8589,
+        // Version: 2.0
+        BLEND_EQUATION_RGB               = 0x8009,
+        VERTEX_ATTRIB_ARRAY_ENABLED      = 0x8622,
+        VERTEX_ATTRIB_ARRAY_SIZE         = 0x8623,
+        VERTEX_ATTRIB_ARRAY_STRIDE       = 0x8624,
+        VERTEX_ATTRIB_ARRAY_TYPE         = 0x8625,
+        CURRENT_VERTEX_ATTRIB            = 0x8626,
+        VERTEX_PROGRAM_POINT_SIZE        = 0x8642,
+        VERTEX_ATTRIB_ARRAY_POINTER      = 0x8645,
+        STENCIL_BACK_FUNC                = 0x8800,
+        STENCIL_BACK_FAIL                = 0x8801,
+        STENCIL_BACK_PASS_DEPTH_FAIL     = 0x8802,
+        STENCIL_BACK_PASS_DEPTH_PASS     = 0x8803,
+        MAX_DRAW_BUFFERS                 = 0x8824,
+        DRAW_BUFFER0                     = 0x8825,
+        DRAW_BUFFER1                     = 0x8826,
+        DRAW_BUFFER2                     = 0x8827,
+        DRAW_BUFFER3                     = 0x8828,
+        DRAW_BUFFER4                     = 0x8829,
+        DRAW_BUFFER5                     = 0x882A,
+        DRAW_BUFFER6                     = 0x882B,
+        DRAW_BUFFER7                     = 0x882C,
+        DRAW_BUFFER8                     = 0x882D,
+        DRAW_BUFFER9                     = 0x882E,
+        DRAW_BUFFER10                    = 0x882F,
+        DRAW_BUFFER11                    = 0x8830,
+        DRAW_BUFFER12                    = 0x8831,
+        DRAW_BUFFER13                    = 0x8832,
+        DRAW_BUFFER14                    = 0x8833,
+        DRAW_BUFFER15                    = 0x8834,
+        BLEND_EQUATION_ALPHA             = 0x883D,
+        MAX_VERTEX_ATTRIBS               = 0x8869,
+        VERTEX_ATTRIB_ARRAY_NORMALIZED   = 0x886A,
+        MAX_TEXTURE_IMAGE_UNITS          = 0x8872,
+        FRAGMENT_SHADER                  = 0x8B30,
+        VERTEX_SHADER                    = 0x8B31,
+        MAX_FRAGMENT_UNIFORM_COMPONENTS  = 0x8B49,
+        MAX_VERTEX_UNIFORM_COMPONENTS    = 0x8B4A,
+        MAX_VARYING_FLOATS               = 0x8B4B,
+        MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C,
+        MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
+        SHADER_TYPE                      = 0x8B4F,
+        FLOAT_VEC2                       = 0x8B50,
+        FLOAT_VEC3                       = 0x8B51,
+        FLOAT_VEC4                       = 0x8B52,
+        INT_VEC2                         = 0x8B53,
+        INT_VEC3                         = 0x8B54,
+        INT_VEC4                         = 0x8B55,
+        BOOL                             = 0x8B56,
+        BOOL_VEC2                        = 0x8B57,
+        BOOL_VEC3                        = 0x8B58,
+        BOOL_VEC4                        = 0x8B59,
+        FLOAT_MAT2                       = 0x8B5A,
+        FLOAT_MAT3                       = 0x8B5B,
+        FLOAT_MAT4                       = 0x8B5C,
+        SAMPLER_1D                       = 0x8B5D,
+        SAMPLER_2D                       = 0x8B5E,
+        SAMPLER_3D                       = 0x8B5F,
+        SAMPLER_CUBE                     = 0x8B60,
+        SAMPLER_1D_SHADOW                = 0x8B61,
+        SAMPLER_2D_SHADOW                = 0x8B62,
+        DELETE_STATUS                    = 0x8B80,
+        COMPILE_STATUS                   = 0x8B81,
+        LINK_STATUS                      = 0x8B82,
+        VALIDATE_STATUS                  = 0x8B83,
+        INFO_LOG_LENGTH                  = 0x8B84,
+        ATTACHED_SHADERS                 = 0x8B85,
+        ACTIVE_UNIFORMS                  = 0x8B86,
+        ACTIVE_UNIFORM_MAX_LENGTH        = 0x8B87,
+        SHADER_SOURCE_LENGTH             = 0x8B88,
+        ACTIVE_ATTRIBUTES                = 0x8B89,
+        ACTIVE_ATTRIBUTE_MAX_LENGTH      = 0x8B8A,
+        FRAGMENT_SHADER_DERIVATIVE_HINT  = 0x8B8B,
+        SHADING_LANGUAGE_VERSION         = 0x8B8C,
+        CURRENT_PROGRAM                  = 0x8B8D,
+        POINT_SPRITE_COORD_ORIGIN        = 0x8CA0,
+        LOWER_LEFT                       = 0x8CA1,
+        UPPER_LEFT                       = 0x8CA2,
+        STENCIL_BACK_REF                 = 0x8CA3,
+        STENCIL_BACK_VALUE_MASK          = 0x8CA4,
+        STENCIL_BACK_WRITEMASK           = 0x8CA5,
 
-    // Version: 2.0
-    BLEND_EQUATION_RGB               = 0x8009,
-    VERTEX_ATTRIB_ARRAY_ENABLED      = 0x8622,
-    VERTEX_ATTRIB_ARRAY_SIZE         = 0x8623,
-    VERTEX_ATTRIB_ARRAY_STRIDE       = 0x8624,
-    VERTEX_ATTRIB_ARRAY_TYPE         = 0x8625,
-    CURRENT_VERTEX_ATTRIB            = 0x8626,
-    VERTEX_PROGRAM_POINT_SIZE        = 0x8642,
-    VERTEX_ATTRIB_ARRAY_POINTER      = 0x8645,
-    STENCIL_BACK_FUNC                = 0x8800,
-    STENCIL_BACK_FAIL                = 0x8801,
-    STENCIL_BACK_PASS_DEPTH_FAIL     = 0x8802,
-    STENCIL_BACK_PASS_DEPTH_PASS     = 0x8803,
-    MAX_DRAW_BUFFERS                 = 0x8824,
-    DRAW_BUFFER0                     = 0x8825,
-    DRAW_BUFFER1                     = 0x8826,
-    DRAW_BUFFER2                     = 0x8827,
-    DRAW_BUFFER3                     = 0x8828,
-    DRAW_BUFFER4                     = 0x8829,
-    DRAW_BUFFER5                     = 0x882A,
-    DRAW_BUFFER6                     = 0x882B,
-    DRAW_BUFFER7                     = 0x882C,
-    DRAW_BUFFER8                     = 0x882D,
-    DRAW_BUFFER9                     = 0x882E,
-    DRAW_BUFFER10                    = 0x882F,
-    DRAW_BUFFER11                    = 0x8830,
-    DRAW_BUFFER12                    = 0x8831,
-    DRAW_BUFFER13                    = 0x8832,
-    DRAW_BUFFER14                    = 0x8833,
-    DRAW_BUFFER15                    = 0x8834,
-    BLEND_EQUATION_ALPHA             = 0x883D,
-    MAX_VERTEX_ATTRIBS               = 0x8869,
-    VERTEX_ATTRIB_ARRAY_NORMALIZED   = 0x886A,
-    MAX_TEXTURE_IMAGE_UNITS          = 0x8872,
-    FRAGMENT_SHADER                  = 0x8B30,
-    VERTEX_SHADER                    = 0x8B31,
-    MAX_FRAGMENT_UNIFORM_COMPONENTS  = 0x8B49,
-    MAX_VERTEX_UNIFORM_COMPONENTS    = 0x8B4A,
-    MAX_VARYING_FLOATS               = 0x8B4B,
-    MAX_VERTEX_TEXTURE_IMAGE_UNITS   = 0x8B4C,
-    MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
-    SHADER_TYPE                      = 0x8B4F,
-    FLOAT_VEC2                       = 0x8B50,
-    FLOAT_VEC3                       = 0x8B51,
-    FLOAT_VEC4                       = 0x8B52,
-    INT_VEC2                         = 0x8B53,
-    INT_VEC3                         = 0x8B54,
-    INT_VEC4                         = 0x8B55,
-    BOOL                             = 0x8B56,
-    BOOL_VEC2                        = 0x8B57,
-    BOOL_VEC3                        = 0x8B58,
-    BOOL_VEC4                        = 0x8B59,
-    FLOAT_MAT2                       = 0x8B5A,
-    FLOAT_MAT3                       = 0x8B5B,
-    FLOAT_MAT4                       = 0x8B5C,
-    SAMPLER_1D                       = 0x8B5D,
-    SAMPLER_2D                       = 0x8B5E,
-    SAMPLER_3D                       = 0x8B5F,
-    SAMPLER_CUBE                     = 0x8B60,
-    SAMPLER_1D_SHADOW                = 0x8B61,
-    SAMPLER_2D_SHADOW                = 0x8B62,
-    DELETE_STATUS                    = 0x8B80,
-    COMPILE_STATUS                   = 0x8B81,
-    LINK_STATUS                      = 0x8B82,
-    VALIDATE_STATUS                  = 0x8B83,
-    INFO_LOG_LENGTH                  = 0x8B84,
-    ATTACHED_SHADERS                 = 0x8B85,
-    ACTIVE_UNIFORMS                  = 0x8B86,
-    ACTIVE_UNIFORM_MAX_LENGTH        = 0x8B87,
-    SHADER_SOURCE_LENGTH             = 0x8B88,
-    ACTIVE_ATTRIBUTES                = 0x8B89,
-    ACTIVE_ATTRIBUTE_MAX_LENGTH      = 0x8B8A,
-    FRAGMENT_SHADER_DERIVATIVE_HINT  = 0x8B8B,
-    SHADING_LANGUAGE_VERSION         = 0x8B8C,
-    CURRENT_PROGRAM                  = 0x8B8D,
-    POINT_SPRITE_COORD_ORIGIN        = 0x8CA0,
-    LOWER_LEFT                       = 0x8CA1,
-    UPPER_LEFT                       = 0x8CA2,
-    STENCIL_BACK_REF                 = 0x8CA3,
-    STENCIL_BACK_VALUE_MASK          = 0x8CA4,
-    STENCIL_BACK_WRITEMASK           = 0x8CA5,
+        // Version: 2.1
+        PIXEL_PACK_BUFFER                = 0x88EB,
+        PIXEL_UNPACK_BUFFER              = 0x88EC,
+        PIXEL_PACK_BUFFER_BINDING        = 0x88ED,
+        PIXEL_UNPACK_BUFFER_BINDING      = 0x88EF,
+        FLOAT_MAT2x3                     = 0x8B65,
+        FLOAT_MAT2x4                     = 0x8B66,
+        FLOAT_MAT3x2                     = 0x8B67,
+        FLOAT_MAT3x4                     = 0x8B68,
+        FLOAT_MAT4x2                     = 0x8B69,
+        FLOAT_MAT4x3                     = 0x8B6A,
+        SRGB                             = 0x8C40,
+        SRGB8                            = 0x8C41,
+        SRGB_ALPHA                       = 0x8C42,
+        SRGB8_ALPHA8                     = 0x8C43,
+        COMPRESSED_SRGB                  = 0x8C48,
+        COMPRESSED_SRGB_ALPHA            = 0x8C49,
 
-    // Version: 2.1
-    PIXEL_PACK_BUFFER                = 0x88EB,
-    PIXEL_UNPACK_BUFFER              = 0x88EC,
-    PIXEL_PACK_BUFFER_BINDING        = 0x88ED,
-    PIXEL_UNPACK_BUFFER_BINDING      = 0x88EF,
-    FLOAT_MAT2x3                     = 0x8B65,
-    FLOAT_MAT2x4                     = 0x8B66,
-    FLOAT_MAT3x2                     = 0x8B67,
-    FLOAT_MAT3x4                     = 0x8B68,
-    FLOAT_MAT4x2                     = 0x8B69,
-    FLOAT_MAT4x3                     = 0x8B6A,
-    SRGB                             = 0x8C40,
-    SRGB8                            = 0x8C41,
-    SRGB_ALPHA                       = 0x8C42,
-    SRGB8_ALPHA8                     = 0x8C43,
-    COMPRESSED_SRGB                  = 0x8C48,
-    COMPRESSED_SRGB_ALPHA            = 0x8C49,
+        // Core Extension: ARB_vertex_array_object
+        VERTEX_ARRAY_BINDING             = 0x85B5,
 
-    // Core Extension: ARB_vertex_array_object
-    VERTEX_ARRAY_BINDING             = 0x85B5,
+        // Core Extension: ARB_texture_rg
+        RG                               = 0x8227,
+        RG_INTEGER                       = 0x8228,
+        R8                               = 0x8229,
+        R16                              = 0x822A,
+        RG8                              = 0x822B,
+        RG16                             = 0x822C,
+        R16F                             = 0x822D,
+        R32F                             = 0x822E,
+        RG16F                            = 0x822F,
+        RG32F                            = 0x8230,
+        R8I                              = 0x8231,
+        R8UI                             = 0x8232,
+        R16I                             = 0x8233,
+        R16UI                            = 0x8234,
+        R32I                             = 0x8235,
+        R32UI                            = 0x8236,
+        RG8I                             = 0x8237,
+        RG8UI                            = 0x8238,
+        RG16I                            = 0x8239,
+        RG16UI                           = 0x823A,
+        RG32I                            = 0x823B,
+        RG32UI                           = 0x823C,
 
-    // Core Extension: ARB_texture_rg
-    RG                               = 0x8227,
-    RG_INTEGER                       = 0x8228,
-    R8                               = 0x8229,
-    R16                              = 0x822A,
-    RG8                              = 0x822B,
-    RG16                             = 0x822C,
-    R16F                             = 0x822D,
-    R32F                             = 0x822E,
-    RG16F                            = 0x822F,
-    RG32F                            = 0x8230,
-    R8I                              = 0x8231,
-    R8UI                             = 0x8232,
-    R16I                             = 0x8233,
-    R16UI                            = 0x8234,
-    R32I                             = 0x8235,
-    R32UI                            = 0x8236,
-    RG8I                             = 0x8237,
-    RG8UI                            = 0x8238,
-    RG16I                            = 0x8239,
-    RG16UI                           = 0x823A,
-    RG32I                            = 0x823B,
-    RG32UI                           = 0x823C,
+        // Core Extension: ARB_texture_compression_rgtc
+        COMPRESSED_RED_RGTC1             = 0x8DBB,
+        COMPRESSED_SIGNED_RED_RGTC1      = 0x8DBC,
+        COMPRESSED_RG_RGTC2              = 0x8DBD,
+        COMPRESSED_SIGNED_RG_RGTC2       = 0x8DBE,
 
-    // Core Extension: ARB_texture_compression_rgtc
-    COMPRESSED_RED_RGTC1             = 0x8DBB,
-    COMPRESSED_SIGNED_RED_RGTC1      = 0x8DBC,
-    COMPRESSED_RG_RGTC2              = 0x8DBD,
-    COMPRESSED_SIGNED_RG_RGTC2       = 0x8DBE,
+        // Core Extension: ARB_map_buffer_range
+        MAP_READ_BIT                     = 0x0001,
+        MAP_WRITE_BIT                    = 0x0002,
+        MAP_INVALIDATE_RANGE_BIT         = 0x0004,
+        MAP_INVALIDATE_BUFFER_BIT        = 0x0008,
+        MAP_FLUSH_EXPLICIT_BIT           = 0x0010,
+        MAP_UNSYNCHRONIZED_BIT           = 0x0020,
 
-    // Core Extension: ARB_map_buffer_range
-    MAP_READ_BIT                     = 0x0001,
-    MAP_WRITE_BIT                    = 0x0002,
-    MAP_INVALIDATE_RANGE_BIT         = 0x0004,
-    MAP_INVALIDATE_BUFFER_BIT        = 0x0008,
-    MAP_FLUSH_EXPLICIT_BIT           = 0x0010,
-    MAP_UNSYNCHRONIZED_BIT           = 0x0020,
+        // Core Extension: ARB_half_float_vertex
+        HALF_FLOAT                       = 0x140B,
 
-    // Core Extension: ARB_half_float_vertex
-    HALF_FLOAT                       = 0x140B,
+        // Core Extension: ARB_framebuffer_sRGB
+        FRAMEBUFFER_SRGB                 = 0x8DB9,
 
-    // Core Extension: ARB_framebuffer_sRGB
-    FRAMEBUFFER_SRGB                 = 0x8DB9,
+        // Core Extension: ARB_framebuffer_object
+        INVALID_FRAMEBUFFER_OPERATION    = 0x0506,
+        FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210,
+        FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211,
+        FRAMEBUFFER_ATTACHMENT_RED_SIZE  = 0x8212,
+        FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213,
+        FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214,
+        FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215,
+        FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216,
+        FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217,
+        FRAMEBUFFER_DEFAULT              = 0x8218,
+        FRAMEBUFFER_UNDEFINED            = 0x8219,
+        DEPTH_STENCIL_ATTACHMENT         = 0x821A,
+        INDEX                            = 0x8222,
+        MAX_RENDERBUFFER_SIZE            = 0x84E8,
+        DEPTH_STENCIL                    = 0x84F9,
+        UNSIGNED_INT_24_8                = 0x84FA,
+        DEPTH24_STENCIL8                 = 0x88F0,
+        TEXTURE_STENCIL_SIZE             = 0x88F1,
+        TEXTURE_RED_TYPE                 = 0x8C10,
+        TEXTURE_GREEN_TYPE               = 0x8C11,
+        TEXTURE_BLUE_TYPE                = 0x8C12,
+        TEXTURE_ALPHA_TYPE               = 0x8C13,
+        TEXTURE_DEPTH_TYPE               = 0x8C16,
+        UNSIGNED_NORMALIZED              = 0x8C17,
+        FRAMEBUFFER_BINDING              = 0x8CA6,
+        DRAW_FRAMEBUFFER_BINDING         = 0x8CA6,
+        RENDERBUFFER_BINDING             = 0x8CA7,
+        READ_FRAMEBUFFER                 = 0x8CA8,
+        DRAW_FRAMEBUFFER                 = 0x8CA9,
+        READ_FRAMEBUFFER_BINDING         = 0x8CAA,
+        RENDERBUFFER_SAMPLES             = 0x8CAB,
+        FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0,
+        FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1,
+        FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2,
+        FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3,
+        FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4,
+        FRAMEBUFFER_COMPLETE             = 0x8CD5,
+        FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6,
+        FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7,
+        FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB,
+        FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC,
+        FRAMEBUFFER_UNSUPPORTED          = 0x8CDD,
+        MAX_COLOR_ATTACHMENTS            = 0x8CDF,
+        COLOR_ATTACHMENT0                = 0x8CE0,
+        COLOR_ATTACHMENT1                = 0x8CE1,
+        COLOR_ATTACHMENT2                = 0x8CE2,
+        COLOR_ATTACHMENT3                = 0x8CE3,
+        COLOR_ATTACHMENT4                = 0x8CE4,
+        COLOR_ATTACHMENT5                = 0x8CE5,
+        COLOR_ATTACHMENT6                = 0x8CE6,
+        COLOR_ATTACHMENT7                = 0x8CE7,
+        COLOR_ATTACHMENT8                = 0x8CE8,
+        COLOR_ATTACHMENT9                = 0x8CE9,
+        COLOR_ATTACHMENT10               = 0x8CEA,
+        COLOR_ATTACHMENT11               = 0x8CEB,
+        COLOR_ATTACHMENT12               = 0x8CEC,
+        COLOR_ATTACHMENT13               = 0x8CED,
+        COLOR_ATTACHMENT14               = 0x8CEE,
+        COLOR_ATTACHMENT15               = 0x8CEF,
+        DEPTH_ATTACHMENT                 = 0x8D00,
+        STENCIL_ATTACHMENT               = 0x8D20,
+        FRAMEBUFFER                      = 0x8D40,
+        RENDERBUFFER                     = 0x8D41,
+        RENDERBUFFER_WIDTH               = 0x8D42,
+        RENDERBUFFER_HEIGHT              = 0x8D43,
+        RENDERBUFFER_INTERNAL_FORMAT     = 0x8D44,
+        STENCIL_INDEX1                   = 0x8D46,
+        STENCIL_INDEX4                   = 0x8D47,
+        STENCIL_INDEX8                   = 0x8D48,
+        STENCIL_INDEX16                  = 0x8D49,
+        RENDERBUFFER_RED_SIZE            = 0x8D50,
+        RENDERBUFFER_GREEN_SIZE          = 0x8D51,
+        RENDERBUFFER_BLUE_SIZE           = 0x8D52,
+        RENDERBUFFER_ALPHA_SIZE          = 0x8D53,
+        RENDERBUFFER_DEPTH_SIZE          = 0x8D54,
+        RENDERBUFFER_STENCIL_SIZE        = 0x8D55,
+        FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56,
+        MAX_SAMPLES                      = 0x8D57,
+        TEXTURE_LUMINANCE_TYPE           = 0x8C14,
+        TEXTURE_INTENSITY_TYPE           = 0x8C15,
 
-    // Core Extension: ARB_framebuffer_object
-    INVALID_FRAMEBUFFER_OPERATION    = 0x0506,
-    FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210,
-    FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211,
-    FRAMEBUFFER_ATTACHMENT_RED_SIZE  = 0x8212,
-    FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213,
-    FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214,
-    FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215,
-    FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216,
-    FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217,
-    FRAMEBUFFER_DEFAULT              = 0x8218,
-    FRAMEBUFFER_UNDEFINED            = 0x8219,
-    DEPTH_STENCIL_ATTACHMENT         = 0x821A,
-    INDEX                            = 0x8222,
-    MAX_RENDERBUFFER_SIZE            = 0x84E8,
-    DEPTH_STENCIL                    = 0x84F9,
-    UNSIGNED_INT_24_8                = 0x84FA,
-    DEPTH24_STENCIL8                 = 0x88F0,
-    TEXTURE_STENCIL_SIZE             = 0x88F1,
-    TEXTURE_RED_TYPE                 = 0x8C10,
-    TEXTURE_GREEN_TYPE               = 0x8C11,
-    TEXTURE_BLUE_TYPE                = 0x8C12,
-    TEXTURE_ALPHA_TYPE               = 0x8C13,
-    TEXTURE_DEPTH_TYPE               = 0x8C16,
-    UNSIGNED_NORMALIZED              = 0x8C17,
-    FRAMEBUFFER_BINDING              = 0x8CA6,
-    DRAW_FRAMEBUFFER_BINDING         = 0x8CA6,
-    RENDERBUFFER_BINDING             = 0x8CA7,
-    READ_FRAMEBUFFER                 = 0x8CA8,
-    DRAW_FRAMEBUFFER                 = 0x8CA9,
-    READ_FRAMEBUFFER_BINDING         = 0x8CAA,
-    RENDERBUFFER_SAMPLES             = 0x8CAB,
-    FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0,
-    FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3,
-    FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4,
-    FRAMEBUFFER_COMPLETE             = 0x8CD5,
-    FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6,
-    FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7,
-    FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB,
-    FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC,
-    FRAMEBUFFER_UNSUPPORTED          = 0x8CDD,
-    MAX_COLOR_ATTACHMENTS            = 0x8CDF,
-    COLOR_ATTACHMENT0                = 0x8CE0,
-    COLOR_ATTACHMENT1                = 0x8CE1,
-    COLOR_ATTACHMENT2                = 0x8CE2,
-    COLOR_ATTACHMENT3                = 0x8CE3,
-    COLOR_ATTACHMENT4                = 0x8CE4,
-    COLOR_ATTACHMENT5                = 0x8CE5,
-    COLOR_ATTACHMENT6                = 0x8CE6,
-    COLOR_ATTACHMENT7                = 0x8CE7,
-    COLOR_ATTACHMENT8                = 0x8CE8,
-    COLOR_ATTACHMENT9                = 0x8CE9,
-    COLOR_ATTACHMENT10               = 0x8CEA,
-    COLOR_ATTACHMENT11               = 0x8CEB,
-    COLOR_ATTACHMENT12               = 0x8CEC,
-    COLOR_ATTACHMENT13               = 0x8CED,
-    COLOR_ATTACHMENT14               = 0x8CEE,
-    COLOR_ATTACHMENT15               = 0x8CEF,
-    DEPTH_ATTACHMENT                 = 0x8D00,
-    STENCIL_ATTACHMENT               = 0x8D20,
-    FRAMEBUFFER                      = 0x8D40,
-    RENDERBUFFER                     = 0x8D41,
-    RENDERBUFFER_WIDTH               = 0x8D42,
-    RENDERBUFFER_HEIGHT              = 0x8D43,
-    RENDERBUFFER_INTERNAL_FORMAT     = 0x8D44,
-    STENCIL_INDEX1                   = 0x8D46,
-    STENCIL_INDEX4                   = 0x8D47,
-    STENCIL_INDEX8                   = 0x8D48,
-    STENCIL_INDEX16                  = 0x8D49,
-    RENDERBUFFER_RED_SIZE            = 0x8D50,
-    RENDERBUFFER_GREEN_SIZE          = 0x8D51,
-    RENDERBUFFER_BLUE_SIZE           = 0x8D52,
-    RENDERBUFFER_ALPHA_SIZE          = 0x8D53,
-    RENDERBUFFER_DEPTH_SIZE          = 0x8D54,
-    RENDERBUFFER_STENCIL_SIZE        = 0x8D55,
-    FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56,
-    MAX_SAMPLES                      = 0x8D57,
-    TEXTURE_LUMINANCE_TYPE           = 0x8C14,
-    TEXTURE_INTENSITY_TYPE           = 0x8C15,
+        // Core Extension: ARB_depth_buffer_float
+        DEPTH_COMPONENT32F               = 0x8CAC,
+        DEPTH32F_STENCIL8                = 0x8CAD,
+        FLOAT_32_UNSIGNED_INT_24_8_REV   = 0x8DAD,
 
-    // Core Extension: ARB_depth_buffer_float
-    DEPTH_COMPONENT32F               = 0x8CAC,
-    DEPTH32F_STENCIL8                = 0x8CAD,
-    FLOAT_32_UNSIGNED_INT_24_8_REV   = 0x8DAD,
+        // Version: 3.0
+        COMPARE_REF_TO_TEXTURE           = 0x884E,
+        CLIP_DISTANCE0                   = 0x3000,
+        CLIP_DISTANCE1                   = 0x3001,
+        CLIP_DISTANCE2                   = 0x3002,
+        CLIP_DISTANCE3                   = 0x3003,
+        CLIP_DISTANCE4                   = 0x3004,
+        CLIP_DISTANCE5                   = 0x3005,
+        CLIP_DISTANCE6                   = 0x3006,
+        CLIP_DISTANCE7                   = 0x3007,
+        MAX_CLIP_DISTANCES               = 0x0D32,
+        MAJOR_VERSION                    = 0x821B,
+        MINOR_VERSION                    = 0x821C,
+        NUM_EXTENSIONS                   = 0x821D,
+        CONTEXT_FLAGS                    = 0x821E,
+        COMPRESSED_RED                   = 0x8225,
+        COMPRESSED_RG                    = 0x8226,
+        CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001,
+        RGBA32F                          = 0x8814,
+        RGB32F                           = 0x8815,
+        RGBA16F                          = 0x881A,
+        RGB16F                           = 0x881B,
+        VERTEX_ATTRIB_ARRAY_INTEGER      = 0x88FD,
+        MAX_ARRAY_TEXTURE_LAYERS         = 0x88FF,
+        MIN_PROGRAM_TEXEL_OFFSET         = 0x8904,
+        MAX_PROGRAM_TEXEL_OFFSET         = 0x8905,
+        CLAMP_READ_COLOR                 = 0x891C,
+        FIXED_ONLY                       = 0x891D,
+        TEXTURE_1D_ARRAY                 = 0x8C18,
+        PROXY_TEXTURE_1D_ARRAY           = 0x8C19,
+        TEXTURE_2D_ARRAY                 = 0x8C1A,
+        PROXY_TEXTURE_2D_ARRAY           = 0x8C1B,
+        TEXTURE_BINDING_1D_ARRAY         = 0x8C1C,
+        TEXTURE_BINDING_2D_ARRAY         = 0x8C1D,
+        R11F_G11F_B10F                   = 0x8C3A,
+        UNSIGNED_INT_10F_11F_11F_REV     = 0x8C3B,
+        RGB9_E5                          = 0x8C3D,
+        UNSIGNED_INT_5_9_9_9_REV         = 0x8C3E,
+        TEXTURE_SHARED_SIZE              = 0x8C3F,
+        TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76,
+        TRANSFORM_FEEDBACK_BUFFER_MODE   = 0x8C7F,
+        MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80,
+        TRANSFORM_FEEDBACK_VARYINGS      = 0x8C83,
+        TRANSFORM_FEEDBACK_BUFFER_START  = 0x8C84,
+        TRANSFORM_FEEDBACK_BUFFER_SIZE   = 0x8C85,
+        PRIMITIVES_GENERATED             = 0x8C87,
+        TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88,
+        RASTERIZER_DISCARD               = 0x8C89,
+        MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A,
+        MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B,
+        INTERLEAVED_ATTRIBS              = 0x8C8C,
+        SEPARATE_ATTRIBS                 = 0x8C8D,
+        TRANSFORM_FEEDBACK_BUFFER        = 0x8C8E,
+        TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F,
+        RGBA32UI                         = 0x8D70,
+        RGB32UI                          = 0x8D71,
+        RGBA16UI                         = 0x8D76,
+        RGB16UI                          = 0x8D77,
+        RGBA8UI                          = 0x8D7C,
+        RGB8UI                           = 0x8D7D,
+        RGBA32I                          = 0x8D82,
+        RGB32I                           = 0x8D83,
+        RGBA16I                          = 0x8D88,
+        RGB16I                           = 0x8D89,
+        RGBA8I                           = 0x8D8E,
+        RGB8I                            = 0x8D8F,
+        RED_INTEGER                      = 0x8D94,
+        GREEN_INTEGER                    = 0x8D95,
+        BLUE_INTEGER                     = 0x8D96,
+        RGB_INTEGER                      = 0x8D98,
+        RGBA_INTEGER                     = 0x8D99,
+        BGR_INTEGER                      = 0x8D9A,
+        BGRA_INTEGER                     = 0x8D9B,
+        SAMPLER_1D_ARRAY                 = 0x8DC0,
+        SAMPLER_2D_ARRAY                 = 0x8DC1,
+        SAMPLER_1D_ARRAY_SHADOW          = 0x8DC3,
+        SAMPLER_2D_ARRAY_SHADOW          = 0x8DC4,
+        SAMPLER_CUBE_SHADOW              = 0x8DC5,
+        UNSIGNED_INT_VEC2                = 0x8DC6,
+        UNSIGNED_INT_VEC3                = 0x8DC7,
+        UNSIGNED_INT_VEC4                = 0x8DC8,
+        INT_SAMPLER_1D                   = 0x8DC9,
+        INT_SAMPLER_2D                   = 0x8DCA,
+        INT_SAMPLER_3D                   = 0x8DCB,
+        INT_SAMPLER_CUBE                 = 0x8DCC,
+        INT_SAMPLER_1D_ARRAY             = 0x8DCE,
+        INT_SAMPLER_2D_ARRAY             = 0x8DCF,
+        UNSIGNED_INT_SAMPLER_1D          = 0x8DD1,
+        UNSIGNED_INT_SAMPLER_2D          = 0x8DD2,
+        UNSIGNED_INT_SAMPLER_3D          = 0x8DD3,
+        UNSIGNED_INT_SAMPLER_CUBE        = 0x8DD4,
+        UNSIGNED_INT_SAMPLER_1D_ARRAY    = 0x8DD6,
+        UNSIGNED_INT_SAMPLER_2D_ARRAY    = 0x8DD7,
+        QUERY_WAIT                       = 0x8E13,
+        QUERY_NO_WAIT                    = 0x8E14,
+        QUERY_BY_REGION_WAIT             = 0x8E15,
+        QUERY_BY_REGION_NO_WAIT          = 0x8E16,
+        BUFFER_ACCESS_FLAGS              = 0x911F,
+        BUFFER_MAP_LENGTH                = 0x9120,
+        BUFFER_MAP_OFFSET                = 0x9121,
 
-    // Version: 3.0
-    COMPARE_REF_TO_TEXTURE           = 0x884E,
-    CLIP_DISTANCE0                   = 0x3000,
-    CLIP_DISTANCE1                   = 0x3001,
-    CLIP_DISTANCE2                   = 0x3002,
-    CLIP_DISTANCE3                   = 0x3003,
-    CLIP_DISTANCE4                   = 0x3004,
-    CLIP_DISTANCE5                   = 0x3005,
-    CLIP_DISTANCE6                   = 0x3006,
-    CLIP_DISTANCE7                   = 0x3007,
-    MAX_CLIP_DISTANCES               = 0x0D32,
-    MAJOR_VERSION                    = 0x821B,
-    MINOR_VERSION                    = 0x821C,
-    NUM_EXTENSIONS                   = 0x821D,
-    CONTEXT_FLAGS                    = 0x821E,
-    COMPRESSED_RED                   = 0x8225,
-    COMPRESSED_RG                    = 0x8226,
-    CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001,
-    RGBA32F                          = 0x8814,
-    RGB32F                           = 0x8815,
-    RGBA16F                          = 0x881A,
-    RGB16F                           = 0x881B,
-    VERTEX_ATTRIB_ARRAY_INTEGER      = 0x88FD,
-    MAX_ARRAY_TEXTURE_LAYERS         = 0x88FF,
-    MIN_PROGRAM_TEXEL_OFFSET         = 0x8904,
-    MAX_PROGRAM_TEXEL_OFFSET         = 0x8905,
-    CLAMP_READ_COLOR                 = 0x891C,
-    FIXED_ONLY                       = 0x891D,
-    TEXTURE_1D_ARRAY                 = 0x8C18,
-    PROXY_TEXTURE_1D_ARRAY           = 0x8C19,
-    TEXTURE_2D_ARRAY                 = 0x8C1A,
-    PROXY_TEXTURE_2D_ARRAY           = 0x8C1B,
-    TEXTURE_BINDING_1D_ARRAY         = 0x8C1C,
-    TEXTURE_BINDING_2D_ARRAY         = 0x8C1D,
-    R11F_G11F_B10F                   = 0x8C3A,
-    UNSIGNED_INT_10F_11F_11F_REV     = 0x8C3B,
-    RGB9_E5                          = 0x8C3D,
-    UNSIGNED_INT_5_9_9_9_REV         = 0x8C3E,
-    TEXTURE_SHARED_SIZE              = 0x8C3F,
-    TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76,
-    TRANSFORM_FEEDBACK_BUFFER_MODE   = 0x8C7F,
-    MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80,
-    TRANSFORM_FEEDBACK_VARYINGS      = 0x8C83,
-    TRANSFORM_FEEDBACK_BUFFER_START  = 0x8C84,
-    TRANSFORM_FEEDBACK_BUFFER_SIZE   = 0x8C85,
-    PRIMITIVES_GENERATED             = 0x8C87,
-    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88,
-    RASTERIZER_DISCARD               = 0x8C89,
-    MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A,
-    MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B,
-    INTERLEAVED_ATTRIBS              = 0x8C8C,
-    SEPARATE_ATTRIBS                 = 0x8C8D,
-    TRANSFORM_FEEDBACK_BUFFER        = 0x8C8E,
-    TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F,
-    RGBA32UI                         = 0x8D70,
-    RGB32UI                          = 0x8D71,
-    RGBA16UI                         = 0x8D76,
-    RGB16UI                          = 0x8D77,
-    RGBA8UI                          = 0x8D7C,
-    RGB8UI                           = 0x8D7D,
-    RGBA32I                          = 0x8D82,
-    RGB32I                           = 0x8D83,
-    RGBA16I                          = 0x8D88,
-    RGB16I                           = 0x8D89,
-    RGBA8I                           = 0x8D8E,
-    RGB8I                            = 0x8D8F,
-    RED_INTEGER                      = 0x8D94,
-    GREEN_INTEGER                    = 0x8D95,
-    BLUE_INTEGER                     = 0x8D96,
-    RGB_INTEGER                      = 0x8D98,
-    RGBA_INTEGER                     = 0x8D99,
-    BGR_INTEGER                      = 0x8D9A,
-    BGRA_INTEGER                     = 0x8D9B,
-    SAMPLER_1D_ARRAY                 = 0x8DC0,
-    SAMPLER_2D_ARRAY                 = 0x8DC1,
-    SAMPLER_1D_ARRAY_SHADOW          = 0x8DC3,
-    SAMPLER_2D_ARRAY_SHADOW          = 0x8DC4,
-    SAMPLER_CUBE_SHADOW              = 0x8DC5,
-    UNSIGNED_INT_VEC2                = 0x8DC6,
-    UNSIGNED_INT_VEC3                = 0x8DC7,
-    UNSIGNED_INT_VEC4                = 0x8DC8,
-    INT_SAMPLER_1D                   = 0x8DC9,
-    INT_SAMPLER_2D                   = 0x8DCA,
-    INT_SAMPLER_3D                   = 0x8DCB,
-    INT_SAMPLER_CUBE                 = 0x8DCC,
-    INT_SAMPLER_1D_ARRAY             = 0x8DCE,
-    INT_SAMPLER_2D_ARRAY             = 0x8DCF,
-    UNSIGNED_INT_SAMPLER_1D          = 0x8DD1,
-    UNSIGNED_INT_SAMPLER_2D          = 0x8DD2,
-    UNSIGNED_INT_SAMPLER_3D          = 0x8DD3,
-    UNSIGNED_INT_SAMPLER_CUBE        = 0x8DD4,
-    UNSIGNED_INT_SAMPLER_1D_ARRAY    = 0x8DD6,
-    UNSIGNED_INT_SAMPLER_2D_ARRAY    = 0x8DD7,
-    QUERY_WAIT                       = 0x8E13,
-    QUERY_NO_WAIT                    = 0x8E14,
-    QUERY_BY_REGION_WAIT             = 0x8E15,
-    QUERY_BY_REGION_NO_WAIT          = 0x8E16,
-    BUFFER_ACCESS_FLAGS              = 0x911F,
-    BUFFER_MAP_LENGTH                = 0x9120,
-    BUFFER_MAP_OFFSET                = 0x9121,
+        // Core Extension: ARB_uniform_buffer_object
+        UNIFORM_BUFFER                   = 0x8A11,
+        UNIFORM_BUFFER_BINDING           = 0x8A28,
+        UNIFORM_BUFFER_START             = 0x8A29,
+        UNIFORM_BUFFER_SIZE              = 0x8A2A,
+        MAX_VERTEX_UNIFORM_BLOCKS        = 0x8A2B,
+        MAX_FRAGMENT_UNIFORM_BLOCKS      = 0x8A2D,
+        MAX_COMBINED_UNIFORM_BLOCKS      = 0x8A2E,
+        MAX_UNIFORM_BUFFER_BINDINGS      = 0x8A2F,
+        MAX_UNIFORM_BLOCK_SIZE           = 0x8A30,
+        MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31,
+        MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33,
+        UNIFORM_BUFFER_OFFSET_ALIGNMENT  = 0x8A34,
+        ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35,
+        ACTIVE_UNIFORM_BLOCKS            = 0x8A36,
+        UNIFORM_TYPE                     = 0x8A37,
+        UNIFORM_SIZE                     = 0x8A38,
+        UNIFORM_NAME_LENGTH              = 0x8A39,
+        UNIFORM_BLOCK_INDEX              = 0x8A3A,
+        UNIFORM_OFFSET                   = 0x8A3B,
+        UNIFORM_ARRAY_STRIDE             = 0x8A3C,
+        UNIFORM_MATRIX_STRIDE            = 0x8A3D,
+        UNIFORM_IS_ROW_MAJOR             = 0x8A3E,
+        UNIFORM_BLOCK_BINDING            = 0x8A3F,
+        UNIFORM_BLOCK_DATA_SIZE          = 0x8A40,
+        UNIFORM_BLOCK_NAME_LENGTH        = 0x8A41,
+        UNIFORM_BLOCK_ACTIVE_UNIFORMS    = 0x8A42,
+        UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43,
+        UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44,
+        UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46,
+        INVALID_INDEX                    = 0xFFFFFFFF,
+        MAX_GEOMETRY_UNIFORM_BLOCKS      = 0x8A2C,
+        MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32,
+        UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45,
 
-    // Core Extension: ARB_uniform_buffer_object
-    UNIFORM_BUFFER                   = 0x8A11,
-    UNIFORM_BUFFER_BINDING           = 0x8A28,
-    UNIFORM_BUFFER_START             = 0x8A29,
-    UNIFORM_BUFFER_SIZE              = 0x8A2A,
-    MAX_VERTEX_UNIFORM_BLOCKS        = 0x8A2B,
-    MAX_FRAGMENT_UNIFORM_BLOCKS      = 0x8A2D,
-    MAX_COMBINED_UNIFORM_BLOCKS      = 0x8A2E,
-    MAX_UNIFORM_BUFFER_BINDINGS      = 0x8A2F,
-    MAX_UNIFORM_BLOCK_SIZE           = 0x8A30,
-    MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31,
-    MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33,
-    UNIFORM_BUFFER_OFFSET_ALIGNMENT  = 0x8A34,
-    ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35,
-    ACTIVE_UNIFORM_BLOCKS            = 0x8A36,
-    UNIFORM_TYPE                     = 0x8A37,
-    UNIFORM_SIZE                     = 0x8A38,
-    UNIFORM_NAME_LENGTH              = 0x8A39,
-    UNIFORM_BLOCK_INDEX              = 0x8A3A,
-    UNIFORM_OFFSET                   = 0x8A3B,
-    UNIFORM_ARRAY_STRIDE             = 0x8A3C,
-    UNIFORM_MATRIX_STRIDE            = 0x8A3D,
-    UNIFORM_IS_ROW_MAJOR             = 0x8A3E,
-    UNIFORM_BLOCK_BINDING            = 0x8A3F,
-    UNIFORM_BLOCK_DATA_SIZE          = 0x8A40,
-    UNIFORM_BLOCK_NAME_LENGTH        = 0x8A41,
-    UNIFORM_BLOCK_ACTIVE_UNIFORMS    = 0x8A42,
-    UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43,
-    UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44,
-    UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46,
-    INVALID_INDEX                    = 0xFFFFFFFF,
-    MAX_GEOMETRY_UNIFORM_BLOCKS      = 0x8A2C,
-    MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32,
-    UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45,
+        // Core Extension: ARB_copy_buffer
+        COPY_READ_BUFFER                 = 0x8F36,
+        COPY_WRITE_BUFFER                = 0x8F37,
+        COPY_READ_BUFFER_BINDING         = 0x8F36,
+        COPY_WRITE_BUFFER_BINDING        = 0x8F37,
 
-    // Core Extension: ARB_copy_buffer
-    COPY_READ_BUFFER                 = 0x8F36,
-    COPY_WRITE_BUFFER                = 0x8F37,
-    COPY_READ_BUFFER_BINDING         = 0x8F36,
-    COPY_WRITE_BUFFER_BINDING        = 0x8F37,
+        // Version: 3.1
+        SAMPLER_2D_RECT                  = 0x8B63,
+        SAMPLER_2D_RECT_SHADOW           = 0x8B64,
+        SAMPLER_BUFFER                   = 0x8DC2,
+        INT_SAMPLER_2D_RECT              = 0x8DCD,
+        INT_SAMPLER_BUFFER               = 0x8DD0,
+        UNSIGNED_INT_SAMPLER_2D_RECT     = 0x8DD5,
+        UNSIGNED_INT_SAMPLER_BUFFER      = 0x8DD8,
+        TEXTURE_BUFFER                   = 0x8C2A,
+        MAX_TEXTURE_BUFFER_SIZE          = 0x8C2B,
+        TEXTURE_BINDING_BUFFER           = 0x8C2C,
+        TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D,
+        TEXTURE_RECTANGLE                = 0x84F5,
+        TEXTURE_BINDING_RECTANGLE        = 0x84F6,
+        PROXY_TEXTURE_RECTANGLE          = 0x84F7,
+        MAX_RECTANGLE_TEXTURE_SIZE       = 0x84F8,
+        RED_SNORM                        = 0x8F90,
+        RG_SNORM                         = 0x8F91,
+        RGB_SNORM                        = 0x8F92,
+        RGBA_SNORM                       = 0x8F93,
+        R8_SNORM                         = 0x8F94,
+        RG8_SNORM                        = 0x8F95,
+        RGB8_SNORM                       = 0x8F96,
+        RGBA8_SNORM                      = 0x8F97,
+        R16_SNORM                        = 0x8F98,
+        RG16_SNORM                       = 0x8F99,
+        RGB16_SNORM                      = 0x8F9A,
+        RGBA16_SNORM                     = 0x8F9B,
+        SIGNED_NORMALIZED                = 0x8F9C,
+        PRIMITIVE_RESTART                = 0x8F9D,
+        PRIMITIVE_RESTART_INDEX          = 0x8F9E,
 
-    // Version: 3.1
-    SAMPLER_2D_RECT                  = 0x8B63,
-    SAMPLER_2D_RECT_SHADOW           = 0x8B64,
-    SAMPLER_BUFFER                   = 0x8DC2,
-    INT_SAMPLER_2D_RECT              = 0x8DCD,
-    INT_SAMPLER_BUFFER               = 0x8DD0,
-    UNSIGNED_INT_SAMPLER_2D_RECT     = 0x8DD5,
-    UNSIGNED_INT_SAMPLER_BUFFER      = 0x8DD8,
-    TEXTURE_BUFFER                   = 0x8C2A,
-    MAX_TEXTURE_BUFFER_SIZE          = 0x8C2B,
-    TEXTURE_BINDING_BUFFER           = 0x8C2C,
-    TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D,
-    TEXTURE_RECTANGLE                = 0x84F5,
-    TEXTURE_BINDING_RECTANGLE        = 0x84F6,
-    PROXY_TEXTURE_RECTANGLE          = 0x84F7,
-    MAX_RECTANGLE_TEXTURE_SIZE       = 0x84F8,
-    RED_SNORM                        = 0x8F90,
-    RG_SNORM                         = 0x8F91,
-    RGB_SNORM                        = 0x8F92,
-    RGBA_SNORM                       = 0x8F93,
-    R8_SNORM                         = 0x8F94,
-    RG8_SNORM                        = 0x8F95,
-    RGB8_SNORM                       = 0x8F96,
-    RGBA8_SNORM                      = 0x8F97,
-    R16_SNORM                        = 0x8F98,
-    RG16_SNORM                       = 0x8F99,
-    RGB16_SNORM                      = 0x8F9A,
-    RGBA16_SNORM                     = 0x8F9B,
-    SIGNED_NORMALIZED                = 0x8F9C,
-    PRIMITIVE_RESTART                = 0x8F9D,
-    PRIMITIVE_RESTART_INDEX          = 0x8F9E,
+        // Legacy
+        VERTEX_ARRAY = 0x8074,
+        NORMAL_ARRAY = 0x8075,
+        COLOR_ARRAY = 0x8076,
+        TEXTURE_COORD_ARRAY = 0x8078,
+        TEXTURE_ENV = 0x2300,
+        TEXTURE_ENV_MODE = 0x2200,
+        MODELVIEW = 0x1700,
+        PROJECTION = 0x1701,
+        LIGHTING = 0x0B50
+    };
 
-  };
+    // Extension: 1.1
+    extern void (CODEGEN_FUNCPTR *CullFace)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *FrontFace)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *Hint)(GLenum target, GLenum mode);
+    extern void (CODEGEN_FUNCPTR *LineWidth)(GLfloat width);
+    extern void (CODEGEN_FUNCPTR *PointSize)(GLfloat size);
+    extern void (CODEGEN_FUNCPTR *PolygonMode)(GLenum face, GLenum mode);
+    extern void (CODEGEN_FUNCPTR *Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
+    extern void (CODEGEN_FUNCPTR *TexParameterf)(GLenum target, GLenum pname, GLfloat param);
+    extern void (CODEGEN_FUNCPTR *TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *TexParameteri)(GLenum target, GLenum pname, GLint param);
+    extern void (CODEGEN_FUNCPTR *TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
+    extern void (CODEGEN_FUNCPTR *TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *DrawBuffer)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *Clear)(GLbitfield mask);
+    extern void (CODEGEN_FUNCPTR *ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    extern void (CODEGEN_FUNCPTR *ClearStencil)(GLint s);
+    extern void (CODEGEN_FUNCPTR *ClearDepth)(GLdouble depth);
+    extern void (CODEGEN_FUNCPTR *StencilMask)(GLuint mask);
+    extern void (CODEGEN_FUNCPTR *ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+    extern void (CODEGEN_FUNCPTR *DepthMask)(GLboolean flag);
+    extern void (CODEGEN_FUNCPTR *Disable)(GLenum cap);
+    extern void (CODEGEN_FUNCPTR *Enable)(GLenum cap);
+    extern void (CODEGEN_FUNCPTR *Finish)();
+    extern void (CODEGEN_FUNCPTR *Flush)();
+    extern void (CODEGEN_FUNCPTR *BlendFunc)(GLenum sfactor, GLenum dfactor);
+    extern void (CODEGEN_FUNCPTR *LogicOp)(GLenum opcode);
+    extern void (CODEGEN_FUNCPTR *StencilFunc)(GLenum func, GLint ref, GLuint mask);
+    extern void (CODEGEN_FUNCPTR *StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
+    extern void (CODEGEN_FUNCPTR *DepthFunc)(GLenum func);
+    extern void (CODEGEN_FUNCPTR *PixelStoref)(GLenum pname, GLfloat param);
+    extern void (CODEGEN_FUNCPTR *PixelStorei)(GLenum pname, GLint param);
+    extern void (CODEGEN_FUNCPTR *ReadBuffer)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *GetBooleanv)(GLenum pname, GLboolean *params);
+    extern void (CODEGEN_FUNCPTR *GetDoublev)(GLenum pname, GLdouble *params);
+    extern GLenum (CODEGEN_FUNCPTR *GetError)();
+    extern void (CODEGEN_FUNCPTR *GetFloatv)(GLenum pname, GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *GetIntegerv)(GLenum pname, GLint *params);
+    extern const GLubyte * (CODEGEN_FUNCPTR *GetString)(GLenum name);
+    extern void (CODEGEN_FUNCPTR *GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *GetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
+    extern GLboolean (CODEGEN_FUNCPTR *IsEnabled)(GLenum cap);
+    extern void (CODEGEN_FUNCPTR *DepthRange)(GLdouble ren_near, GLdouble ren_far);
+    extern void (CODEGEN_FUNCPTR *Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
+    extern void (CODEGEN_FUNCPTR *DrawArrays)(GLenum mode, GLint first, GLsizei count);
+    extern void (CODEGEN_FUNCPTR *DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
+    extern void (CODEGEN_FUNCPTR *GetPointerv)(GLenum pname, GLvoid* *params);
+    extern void (CODEGEN_FUNCPTR *PolygonOffset)(GLfloat factor, GLfloat units);
+    extern void (CODEGEN_FUNCPTR *CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
+    extern void (CODEGEN_FUNCPTR *CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+    extern void (CODEGEN_FUNCPTR *CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+    extern void (CODEGEN_FUNCPTR *CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+    extern void (CODEGEN_FUNCPTR *TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *BindTexture)(GLenum target, GLuint texture);
+    extern void (CODEGEN_FUNCPTR *DeleteTextures)(GLsizei n, const GLuint *textures);
+    extern void (CODEGEN_FUNCPTR *GenTextures)(GLsizei n, GLuint *textures);
+    extern GLboolean (CODEGEN_FUNCPTR *IsTexture)(GLuint texture);
+    extern void (CODEGEN_FUNCPTR *Indexub)(GLubyte c);
+    extern void (CODEGEN_FUNCPTR *Indexubv)(const GLubyte *c);
 
-  // Extension: 1.1
-  extern void (CODEGEN_FUNCPTR *CullFace)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *FrontFace)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *Hint)(GLenum target, GLenum mode);
-  extern void (CODEGEN_FUNCPTR *LineWidth)(GLfloat width);
-  extern void (CODEGEN_FUNCPTR *PointSize)(GLfloat size);
-  extern void (CODEGEN_FUNCPTR *PolygonMode)(GLenum face, GLenum mode);
-  extern void (CODEGEN_FUNCPTR *Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
-  extern void (CODEGEN_FUNCPTR *TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-  extern void (CODEGEN_FUNCPTR *TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *TexParameteri)(GLenum target, GLenum pname, GLint param);
-  extern void (CODEGEN_FUNCPTR *TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
-  extern void (CODEGEN_FUNCPTR *TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *DrawBuffer)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *Clear)(GLbitfield mask);
-  extern void (CODEGEN_FUNCPTR *ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-  extern void (CODEGEN_FUNCPTR *ClearStencil)(GLint s);
-  extern void (CODEGEN_FUNCPTR *ClearDepth)(GLdouble depth);
-  extern void (CODEGEN_FUNCPTR *StencilMask)(GLuint mask);
-  extern void (CODEGEN_FUNCPTR *ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-  extern void (CODEGEN_FUNCPTR *DepthMask)(GLboolean flag);
-  extern void (CODEGEN_FUNCPTR *Disable)(GLenum cap);
-  extern void (CODEGEN_FUNCPTR *Enable)(GLenum cap);
-  extern void (CODEGEN_FUNCPTR *Finish)();
-  extern void (CODEGEN_FUNCPTR *Flush)();
-  extern void (CODEGEN_FUNCPTR *BlendFunc)(GLenum sfactor, GLenum dfactor);
-  extern void (CODEGEN_FUNCPTR *LogicOp)(GLenum opcode);
-  extern void (CODEGEN_FUNCPTR *StencilFunc)(GLenum func, GLint ref, GLuint mask);
-  extern void (CODEGEN_FUNCPTR *StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
-  extern void (CODEGEN_FUNCPTR *DepthFunc)(GLenum func);
-  extern void (CODEGEN_FUNCPTR *PixelStoref)(GLenum pname, GLfloat param);
-  extern void (CODEGEN_FUNCPTR *PixelStorei)(GLenum pname, GLint param);
-  extern void (CODEGEN_FUNCPTR *ReadBuffer)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *GetBooleanv)(GLenum pname, GLboolean *params);
-  extern void (CODEGEN_FUNCPTR *GetDoublev)(GLenum pname, GLdouble *params);
-  extern GLenum (CODEGEN_FUNCPTR *GetError)();
-  extern void (CODEGEN_FUNCPTR *GetFloatv)(GLenum pname, GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *GetIntegerv)(GLenum pname, GLint *params);
-  extern const GLubyte * (CODEGEN_FUNCPTR *GetString)(GLenum name);
-  extern void (CODEGEN_FUNCPTR *GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *GetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
-  extern GLboolean (CODEGEN_FUNCPTR *IsEnabled)(GLenum cap);
-  extern void (CODEGEN_FUNCPTR *DepthRange)(GLdouble ren_near, GLdouble ren_far);
-  extern void (CODEGEN_FUNCPTR *Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
-  extern void (CODEGEN_FUNCPTR *DrawArrays)(GLenum mode, GLint first, GLsizei count);
-  extern void (CODEGEN_FUNCPTR *DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-  extern void (CODEGEN_FUNCPTR *GetPointerv)(GLenum pname, GLvoid* *params);
-  extern void (CODEGEN_FUNCPTR *PolygonOffset)(GLfloat factor, GLfloat units);
-  extern void (CODEGEN_FUNCPTR *CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-  extern void (CODEGEN_FUNCPTR *CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-  extern void (CODEGEN_FUNCPTR *CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-  extern void (CODEGEN_FUNCPTR *CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-  extern void (CODEGEN_FUNCPTR *TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *BindTexture)(GLenum target, GLuint texture);
-  extern void (CODEGEN_FUNCPTR *DeleteTextures)(GLsizei n, const GLuint *textures);
-  extern void (CODEGEN_FUNCPTR *GenTextures)(GLsizei n, GLuint *textures);
-  extern GLboolean (CODEGEN_FUNCPTR *IsTexture)(GLuint texture);
-  extern void (CODEGEN_FUNCPTR *Indexub)(GLubyte c);
-  extern void (CODEGEN_FUNCPTR *Indexubv)(const GLubyte *c);
+    // Extension: 1.2
+    extern void (CODEGEN_FUNCPTR *BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+    extern void (CODEGEN_FUNCPTR *BlendEquation)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
+    extern void (CODEGEN_FUNCPTR *TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
+    extern void (CODEGEN_FUNCPTR *CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 
-  // Extension: 1.2
-  extern void (CODEGEN_FUNCPTR *BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-  extern void (CODEGEN_FUNCPTR *BlendEquation)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-  extern void (CODEGEN_FUNCPTR *TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-  extern void (CODEGEN_FUNCPTR *CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+    // Extension: 1.3
+    extern void (CODEGEN_FUNCPTR *ActiveTexture)(GLenum texture);
+    extern void (CODEGEN_FUNCPTR *SampleCoverage)(GLfloat value, GLboolean invert);
+    extern void (CODEGEN_FUNCPTR *CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img);
 
-  // Extension: 1.3
-  extern void (CODEGEN_FUNCPTR *ActiveTexture)(GLenum texture);
-  extern void (CODEGEN_FUNCPTR *SampleCoverage)(GLfloat value, GLboolean invert);
-  extern void (CODEGEN_FUNCPTR *CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img);
+    // Extension: 1.4
+    extern void (CODEGEN_FUNCPTR *BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+    extern void (CODEGEN_FUNCPTR *MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
+    extern void (CODEGEN_FUNCPTR *MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
+    extern void (CODEGEN_FUNCPTR *PointParameterf)(GLenum pname, GLfloat param);
+    extern void (CODEGEN_FUNCPTR *PointParameterfv)(GLenum pname, const GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *PointParameteri)(GLenum pname, GLint param);
+    extern void (CODEGEN_FUNCPTR *PointParameteriv)(GLenum pname, const GLint *params);
 
-  // Extension: 1.4
-  extern void (CODEGEN_FUNCPTR *BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-  extern void (CODEGEN_FUNCPTR *MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-  extern void (CODEGEN_FUNCPTR *MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-  extern void (CODEGEN_FUNCPTR *PointParameterf)(GLenum pname, GLfloat param);
-  extern void (CODEGEN_FUNCPTR *PointParameterfv)(GLenum pname, const GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *PointParameteri)(GLenum pname, GLint param);
-  extern void (CODEGEN_FUNCPTR *PointParameteriv)(GLenum pname, const GLint *params);
+    // Extension: 1.5
+    extern void (CODEGEN_FUNCPTR *GenQueries)(GLsizei n, GLuint *ids);
+    extern void (CODEGEN_FUNCPTR *DeleteQueries)(GLsizei n, const GLuint *ids);
+    extern GLboolean (CODEGEN_FUNCPTR *IsQuery)(GLuint id);
+    extern void (CODEGEN_FUNCPTR *BeginQuery)(GLenum target, GLuint id);
+    extern void (CODEGEN_FUNCPTR *EndQuery)(GLenum target);
+    extern void (CODEGEN_FUNCPTR *GetQueryiv)(GLenum target, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
+    extern void (CODEGEN_FUNCPTR *BindBuffer)(GLenum target, GLuint buffer);
+    extern void (CODEGEN_FUNCPTR *DeleteBuffers)(GLsizei n, const GLuint *buffers);
+    extern void (CODEGEN_FUNCPTR *GenBuffers)(GLsizei n, GLuint *buffers);
+    extern GLboolean (CODEGEN_FUNCPTR *IsBuffer)(GLuint buffer);
+    extern void (CODEGEN_FUNCPTR *BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+    extern void (CODEGEN_FUNCPTR *BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
+    extern void (CODEGEN_FUNCPTR *GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
+    extern GLvoid* (CODEGEN_FUNCPTR *MapBuffer)(GLenum target, GLenum access);
+    extern GLboolean (CODEGEN_FUNCPTR *UnmapBuffer)(GLenum target);
+    extern void (CODEGEN_FUNCPTR *GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params);
 
-  // Extension: 1.5
-  extern void (CODEGEN_FUNCPTR *GenQueries)(GLsizei n, GLuint *ids);
-  extern void (CODEGEN_FUNCPTR *DeleteQueries)(GLsizei n, const GLuint *ids);
-  extern GLboolean (CODEGEN_FUNCPTR *IsQuery)(GLuint id);
-  extern void (CODEGEN_FUNCPTR *BeginQuery)(GLenum target, GLuint id);
-  extern void (CODEGEN_FUNCPTR *EndQuery)(GLenum target);
-  extern void (CODEGEN_FUNCPTR *GetQueryiv)(GLenum target, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
-  extern void (CODEGEN_FUNCPTR *BindBuffer)(GLenum target, GLuint buffer);
-  extern void (CODEGEN_FUNCPTR *DeleteBuffers)(GLsizei n, const GLuint *buffers);
-  extern void (CODEGEN_FUNCPTR *GenBuffers)(GLsizei n, GLuint *buffers);
-  extern GLboolean (CODEGEN_FUNCPTR *IsBuffer)(GLuint buffer);
-  extern void (CODEGEN_FUNCPTR *BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-  extern void (CODEGEN_FUNCPTR *BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-  extern void (CODEGEN_FUNCPTR *GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-  extern GLvoid* (CODEGEN_FUNCPTR *MapBuffer)(GLenum target, GLenum access);
-  extern GLboolean (CODEGEN_FUNCPTR *UnmapBuffer)(GLenum target);
-  extern void (CODEGEN_FUNCPTR *GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params);
+    // Extension: 2.0
+    extern void (CODEGEN_FUNCPTR *BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
+    extern void (CODEGEN_FUNCPTR *DrawBuffers)(GLsizei n, const GLenum *bufs);
+    extern void (CODEGEN_FUNCPTR *StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
+    extern void (CODEGEN_FUNCPTR *StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
+    extern void (CODEGEN_FUNCPTR *StencilMaskSeparate)(GLenum face, GLuint mask);
+    extern void (CODEGEN_FUNCPTR *AttachShader)(GLuint program, GLuint shader);
+    extern void (CODEGEN_FUNCPTR *BindAttribLocation)(GLuint program, GLuint index, const GLchar *name);
+    extern void (CODEGEN_FUNCPTR *CompileShader)(GLuint shader);
+    extern GLuint (CODEGEN_FUNCPTR *CreateProgram)();
+    extern GLuint (CODEGEN_FUNCPTR *CreateShader)(GLenum type);
+    extern void (CODEGEN_FUNCPTR *DeleteProgram)(GLuint program);
+    extern void (CODEGEN_FUNCPTR *DeleteShader)(GLuint shader);
+    extern void (CODEGEN_FUNCPTR *DetachShader)(GLuint program, GLuint shader);
+    extern void (CODEGEN_FUNCPTR *DisableVertexAttribArray)(GLuint index);
+    extern void (CODEGEN_FUNCPTR *EnableVertexAttribArray)(GLuint index);
+    extern void (CODEGEN_FUNCPTR *GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+    extern void (CODEGEN_FUNCPTR *GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
+    extern void (CODEGEN_FUNCPTR *GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
+    extern GLint (CODEGEN_FUNCPTR *GetAttribLocation)(GLuint program, const GLchar *name);
+    extern void (CODEGEN_FUNCPTR *GetProgramiv)(GLuint program, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+    extern void (CODEGEN_FUNCPTR *GetShaderiv)(GLuint shader, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+    extern void (CODEGEN_FUNCPTR *GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
+    extern GLint (CODEGEN_FUNCPTR *GetUniformLocation)(GLuint program, const GLchar *name);
+    extern void (CODEGEN_FUNCPTR *GetUniformfv)(GLuint program, GLint location, GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *GetUniformiv)(GLuint program, GLint location, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer);
+    extern GLboolean (CODEGEN_FUNCPTR *IsProgram)(GLuint program);
+    extern GLboolean (CODEGEN_FUNCPTR *IsShader)(GLuint shader);
+    extern void (CODEGEN_FUNCPTR *LinkProgram)(GLuint program);
+    extern void (CODEGEN_FUNCPTR *ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
+    extern void (CODEGEN_FUNCPTR *UseProgram)(GLuint program);
+    extern void (CODEGEN_FUNCPTR *Uniform1f)(GLint location, GLfloat v0);
+    extern void (CODEGEN_FUNCPTR *Uniform2f)(GLint location, GLfloat v0, GLfloat v1);
+    extern void (CODEGEN_FUNCPTR *Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+    extern void (CODEGEN_FUNCPTR *Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+    extern void (CODEGEN_FUNCPTR *Uniform1i)(GLint location, GLint v0);
+    extern void (CODEGEN_FUNCPTR *Uniform2i)(GLint location, GLint v0, GLint v1);
+    extern void (CODEGEN_FUNCPTR *Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
+    extern void (CODEGEN_FUNCPTR *Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+    extern void (CODEGEN_FUNCPTR *Uniform1fv)(GLint location, GLsizei count, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *Uniform2fv)(GLint location, GLsizei count, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *Uniform3fv)(GLint location, GLsizei count, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *Uniform4fv)(GLint location, GLsizei count, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *Uniform1iv)(GLint location, GLsizei count, const GLint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform2iv)(GLint location, GLsizei count, const GLint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform3iv)(GLint location, GLsizei count, const GLint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform4iv)(GLint location, GLsizei count, const GLint *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *ValidateProgram)(GLuint program);
+    extern void (CODEGEN_FUNCPTR *VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
 
-  // Extension: 2.0
-  extern void (CODEGEN_FUNCPTR *BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-  extern void (CODEGEN_FUNCPTR *DrawBuffers)(GLsizei n, const GLenum *bufs);
-  extern void (CODEGEN_FUNCPTR *StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-  extern void (CODEGEN_FUNCPTR *StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-  extern void (CODEGEN_FUNCPTR *StencilMaskSeparate)(GLenum face, GLuint mask);
-  extern void (CODEGEN_FUNCPTR *AttachShader)(GLuint program, GLuint shader);
-  extern void (CODEGEN_FUNCPTR *BindAttribLocation)(GLuint program, GLuint index, const GLchar *name);
-  extern void (CODEGEN_FUNCPTR *CompileShader)(GLuint shader);
-  extern GLuint (CODEGEN_FUNCPTR *CreateProgram)();
-  extern GLuint (CODEGEN_FUNCPTR *CreateShader)(GLenum type);
-  extern void (CODEGEN_FUNCPTR *DeleteProgram)(GLuint program);
-  extern void (CODEGEN_FUNCPTR *DeleteShader)(GLuint shader);
-  extern void (CODEGEN_FUNCPTR *DetachShader)(GLuint program, GLuint shader);
-  extern void (CODEGEN_FUNCPTR *DisableVertexAttribArray)(GLuint index);
-  extern void (CODEGEN_FUNCPTR *EnableVertexAttribArray)(GLuint index);
-  extern void (CODEGEN_FUNCPTR *GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-  extern void (CODEGEN_FUNCPTR *GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-  extern void (CODEGEN_FUNCPTR *GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj);
-  extern GLint (CODEGEN_FUNCPTR *GetAttribLocation)(GLuint program, const GLchar *name);
-  extern void (CODEGEN_FUNCPTR *GetProgramiv)(GLuint program, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-  extern void (CODEGEN_FUNCPTR *GetShaderiv)(GLuint shader, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-  extern void (CODEGEN_FUNCPTR *GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-  extern GLint (CODEGEN_FUNCPTR *GetUniformLocation)(GLuint program, const GLchar *name);
-  extern void (CODEGEN_FUNCPTR *GetUniformfv)(GLuint program, GLint location, GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *GetUniformiv)(GLuint program, GLint location, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer);
-  extern GLboolean (CODEGEN_FUNCPTR *IsProgram)(GLuint program);
-  extern GLboolean (CODEGEN_FUNCPTR *IsShader)(GLuint shader);
-  extern void (CODEGEN_FUNCPTR *LinkProgram)(GLuint program);
-  extern void (CODEGEN_FUNCPTR *ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-  extern void (CODEGEN_FUNCPTR *UseProgram)(GLuint program);
-  extern void (CODEGEN_FUNCPTR *Uniform1f)(GLint location, GLfloat v0);
-  extern void (CODEGEN_FUNCPTR *Uniform2f)(GLint location, GLfloat v0, GLfloat v1);
-  extern void (CODEGEN_FUNCPTR *Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-  extern void (CODEGEN_FUNCPTR *Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-  extern void (CODEGEN_FUNCPTR *Uniform1i)(GLint location, GLint v0);
-  extern void (CODEGEN_FUNCPTR *Uniform2i)(GLint location, GLint v0, GLint v1);
-  extern void (CODEGEN_FUNCPTR *Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
-  extern void (CODEGEN_FUNCPTR *Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-  extern void (CODEGEN_FUNCPTR *Uniform1fv)(GLint location, GLsizei count, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *Uniform2fv)(GLint location, GLsizei count, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *Uniform3fv)(GLint location, GLsizei count, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *Uniform4fv)(GLint location, GLsizei count, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *Uniform1iv)(GLint location, GLsizei count, const GLint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform2iv)(GLint location, GLsizei count, const GLint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform3iv)(GLint location, GLsizei count, const GLint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform4iv)(GLint location, GLsizei count, const GLint *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *ValidateProgram)(GLuint program);
-  extern void (CODEGEN_FUNCPTR *VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
+    // Extension: 2.1
+    extern void (CODEGEN_FUNCPTR *UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
 
-  // Extension: 2.1
-  extern void (CODEGEN_FUNCPTR *UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+    // Extension: ARB_vertex_array_object
+    extern void (CODEGEN_FUNCPTR *BindVertexArray)(GLuint ren_array);
+    extern void (CODEGEN_FUNCPTR *DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
+    extern void (CODEGEN_FUNCPTR *GenVertexArrays)(GLsizei n, GLuint *arrays);
+    extern GLboolean (CODEGEN_FUNCPTR *IsVertexArray)(GLuint ren_array);
 
-  // Extension: ARB_vertex_array_object
-  extern void (CODEGEN_FUNCPTR *BindVertexArray)(GLuint ren_array);
-  extern void (CODEGEN_FUNCPTR *DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
-  extern void (CODEGEN_FUNCPTR *GenVertexArrays)(GLsizei n, GLuint *arrays);
-  extern GLboolean (CODEGEN_FUNCPTR *IsVertexArray)(GLuint ren_array);
+    // Extension: ARB_map_buffer_range
+    extern GLvoid* (CODEGEN_FUNCPTR *MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
+    extern void (CODEGEN_FUNCPTR *FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
 
-  // Extension: ARB_map_buffer_range
-  extern GLvoid* (CODEGEN_FUNCPTR *MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-  extern void (CODEGEN_FUNCPTR *FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
+    // Extension: ARB_framebuffer_object
+    extern GLboolean (CODEGEN_FUNCPTR *IsRenderbuffer)(GLuint renderbuffer);
+    extern void (CODEGEN_FUNCPTR *BindRenderbuffer)(GLenum target, GLuint renderbuffer);
+    extern void (CODEGEN_FUNCPTR *DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
+    extern void (CODEGEN_FUNCPTR *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
+    extern void (CODEGEN_FUNCPTR *RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+    extern void (CODEGEN_FUNCPTR *GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
+    extern GLboolean (CODEGEN_FUNCPTR *IsFramebuffer)(GLuint framebuffer);
+    extern void (CODEGEN_FUNCPTR *BindFramebuffer)(GLenum target, GLuint framebuffer);
+    extern void (CODEGEN_FUNCPTR *DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
+    extern void (CODEGEN_FUNCPTR *GenFramebuffers)(GLsizei n, GLuint *framebuffers);
+    extern GLenum (CODEGEN_FUNCPTR *CheckFramebufferStatus)(GLenum target);
+    extern void (CODEGEN_FUNCPTR *FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+    extern void (CODEGEN_FUNCPTR *FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+    extern void (CODEGEN_FUNCPTR *FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+    extern void (CODEGEN_FUNCPTR *FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+    extern void (CODEGEN_FUNCPTR *GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GenerateMipmap)(GLenum target);
+    extern void (CODEGEN_FUNCPTR *BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+    extern void (CODEGEN_FUNCPTR *RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
+    extern void (CODEGEN_FUNCPTR *FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
 
-  // Extension: ARB_framebuffer_object
-  extern GLboolean (CODEGEN_FUNCPTR *IsRenderbuffer)(GLuint renderbuffer);
-  extern void (CODEGEN_FUNCPTR *BindRenderbuffer)(GLenum target, GLuint renderbuffer);
-  extern void (CODEGEN_FUNCPTR *DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
-  extern void (CODEGEN_FUNCPTR *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
-  extern void (CODEGEN_FUNCPTR *RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-  extern void (CODEGEN_FUNCPTR *GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-  extern GLboolean (CODEGEN_FUNCPTR *IsFramebuffer)(GLuint framebuffer);
-  extern void (CODEGEN_FUNCPTR *BindFramebuffer)(GLenum target, GLuint framebuffer);
-  extern void (CODEGEN_FUNCPTR *DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
-  extern void (CODEGEN_FUNCPTR *GenFramebuffers)(GLsizei n, GLuint *framebuffers);
-  extern GLenum (CODEGEN_FUNCPTR *CheckFramebufferStatus)(GLenum target);
-  extern void (CODEGEN_FUNCPTR *FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-  extern void (CODEGEN_FUNCPTR *FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-  extern void (CODEGEN_FUNCPTR *FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-  extern void (CODEGEN_FUNCPTR *FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-  extern void (CODEGEN_FUNCPTR *GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GenerateMipmap)(GLenum target);
-  extern void (CODEGEN_FUNCPTR *BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-  extern void (CODEGEN_FUNCPTR *RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-  extern void (CODEGEN_FUNCPTR *FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+    // Extension: 3.0
+    extern void (CODEGEN_FUNCPTR *ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
+    extern void (CODEGEN_FUNCPTR *GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
+    extern void (CODEGEN_FUNCPTR *GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
+    extern void (CODEGEN_FUNCPTR *Enablei)(GLenum target, GLuint index);
+    extern void (CODEGEN_FUNCPTR *Disablei)(GLenum target, GLuint index);
+    extern GLboolean (CODEGEN_FUNCPTR *IsEnabledi)(GLenum target, GLuint index);
+    extern void (CODEGEN_FUNCPTR *BeginTransformFeedback)(GLenum primitiveMode);
+    extern void (CODEGEN_FUNCPTR *EndTransformFeedback)();
+    extern void (CODEGEN_FUNCPTR *BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+    extern void (CODEGEN_FUNCPTR *BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
+    extern void (CODEGEN_FUNCPTR *TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
+    extern void (CODEGEN_FUNCPTR *GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
+    extern void (CODEGEN_FUNCPTR *ClampColor)(GLenum target, GLenum clamp);
+    extern void (CODEGEN_FUNCPTR *BeginConditionalRender)(GLuint id, GLenum mode);
+    extern void (CODEGEN_FUNCPTR *EndConditionalRender)();
+    extern void (CODEGEN_FUNCPTR *VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI1i)(GLuint index, GLint x);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI2i)(GLuint index, GLint x, GLint y);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI1ui)(GLuint index, GLuint x);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI1iv)(GLuint index, const GLint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI2iv)(GLuint index, const GLint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI3iv)(GLuint index, const GLint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4iv)(GLuint index, const GLint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI1uiv)(GLuint index, const GLuint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI2uiv)(GLuint index, const GLuint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI3uiv)(GLuint index, const GLuint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4uiv)(GLuint index, const GLuint *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4bv)(GLuint index, const GLbyte *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4sv)(GLuint index, const GLshort *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4ubv)(GLuint index, const GLubyte *v);
+    extern void (CODEGEN_FUNCPTR *VertexAttribI4usv)(GLuint index, const GLushort *v);
+    extern void (CODEGEN_FUNCPTR *GetUniformuiv)(GLuint program, GLint location, GLuint *params);
+    extern void (CODEGEN_FUNCPTR *BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name);
+    extern GLint (CODEGEN_FUNCPTR *GetFragDataLocation)(GLuint program, const GLchar *name);
+    extern void (CODEGEN_FUNCPTR *Uniform1ui)(GLint location, GLuint v0);
+    extern void (CODEGEN_FUNCPTR *Uniform2ui)(GLint location, GLuint v0, GLuint v1);
+    extern void (CODEGEN_FUNCPTR *Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
+    extern void (CODEGEN_FUNCPTR *Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+    extern void (CODEGEN_FUNCPTR *Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
+    extern void (CODEGEN_FUNCPTR *Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
+    extern void (CODEGEN_FUNCPTR *TexParameterIiv)(GLenum target, GLenum pname, const GLint *params);
+    extern void (CODEGEN_FUNCPTR *TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params);
+    extern void (CODEGEN_FUNCPTR *GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params);
+    extern void (CODEGEN_FUNCPTR *ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
+    extern void (CODEGEN_FUNCPTR *ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
+    extern void (CODEGEN_FUNCPTR *ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+    extern void (CODEGEN_FUNCPTR *ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
+    extern const GLubyte * (CODEGEN_FUNCPTR *GetStringi)(GLenum name, GLuint index);
 
-  // Extension: 3.0
-  extern void (CODEGEN_FUNCPTR *ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-  extern void (CODEGEN_FUNCPTR *GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
-  extern void (CODEGEN_FUNCPTR *GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
-  extern void (CODEGEN_FUNCPTR *Enablei)(GLenum target, GLuint index);
-  extern void (CODEGEN_FUNCPTR *Disablei)(GLenum target, GLuint index);
-  extern GLboolean (CODEGEN_FUNCPTR *IsEnabledi)(GLenum target, GLuint index);
-  extern void (CODEGEN_FUNCPTR *BeginTransformFeedback)(GLenum primitiveMode);
-  extern void (CODEGEN_FUNCPTR *EndTransformFeedback)();
-  extern void (CODEGEN_FUNCPTR *BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-  extern void (CODEGEN_FUNCPTR *BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
-  extern void (CODEGEN_FUNCPTR *TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-  extern void (CODEGEN_FUNCPTR *GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-  extern void (CODEGEN_FUNCPTR *ClampColor)(GLenum target, GLenum clamp);
-  extern void (CODEGEN_FUNCPTR *BeginConditionalRender)(GLuint id, GLenum mode);
-  extern void (CODEGEN_FUNCPTR *EndConditionalRender)();
-  extern void (CODEGEN_FUNCPTR *VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI1i)(GLuint index, GLint x);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI2i)(GLuint index, GLint x, GLint y);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI1ui)(GLuint index, GLuint x);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI1iv)(GLuint index, const GLint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI2iv)(GLuint index, const GLint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI3iv)(GLuint index, const GLint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4iv)(GLuint index, const GLint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI1uiv)(GLuint index, const GLuint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI2uiv)(GLuint index, const GLuint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI3uiv)(GLuint index, const GLuint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4uiv)(GLuint index, const GLuint *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4bv)(GLuint index, const GLbyte *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4sv)(GLuint index, const GLshort *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4ubv)(GLuint index, const GLubyte *v);
-  extern void (CODEGEN_FUNCPTR *VertexAttribI4usv)(GLuint index, const GLushort *v);
-  extern void (CODEGEN_FUNCPTR *GetUniformuiv)(GLuint program, GLint location, GLuint *params);
-  extern void (CODEGEN_FUNCPTR *BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name);
-  extern GLint (CODEGEN_FUNCPTR *GetFragDataLocation)(GLuint program, const GLchar *name);
-  extern void (CODEGEN_FUNCPTR *Uniform1ui)(GLint location, GLuint v0);
-  extern void (CODEGEN_FUNCPTR *Uniform2ui)(GLint location, GLuint v0, GLuint v1);
-  extern void (CODEGEN_FUNCPTR *Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
-  extern void (CODEGEN_FUNCPTR *Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-  extern void (CODEGEN_FUNCPTR *Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
-  extern void (CODEGEN_FUNCPTR *Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
-  extern void (CODEGEN_FUNCPTR *TexParameterIiv)(GLenum target, GLenum pname, const GLint *params);
-  extern void (CODEGEN_FUNCPTR *TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params);
-  extern void (CODEGEN_FUNCPTR *GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params);
-  extern void (CODEGEN_FUNCPTR *ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
-  extern void (CODEGEN_FUNCPTR *ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
-  extern void (CODEGEN_FUNCPTR *ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-  extern void (CODEGEN_FUNCPTR *ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-  extern const GLubyte * (CODEGEN_FUNCPTR *GetStringi)(GLenum name, GLuint index);
+    // Extension: ARB_uniform_buffer_object
+    extern void (CODEGEN_FUNCPTR *GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
+    extern void (CODEGEN_FUNCPTR *GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
+    extern GLuint (CODEGEN_FUNCPTR *GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
+    extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
+    extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
+    extern void (CODEGEN_FUNCPTR *UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
 
-  // Extension: ARB_uniform_buffer_object
-  extern void (CODEGEN_FUNCPTR *GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-  extern void (CODEGEN_FUNCPTR *GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-  extern GLuint (CODEGEN_FUNCPTR *GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
-  extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-  extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-  extern void (CODEGEN_FUNCPTR *UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+    // Extension: ARB_copy_buffer
+    extern void (CODEGEN_FUNCPTR *CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
 
-  // Extension: ARB_copy_buffer
-  extern void (CODEGEN_FUNCPTR *CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
+    // Extension: 3.1
+    extern void (CODEGEN_FUNCPTR *DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+    extern void (CODEGEN_FUNCPTR *DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
+    extern void (CODEGEN_FUNCPTR *TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);
+    extern void (CODEGEN_FUNCPTR *PrimitiveRestartIndex)(GLuint index);
 
-  // Extension: 3.1
-  extern void (CODEGEN_FUNCPTR *DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-  extern void (CODEGEN_FUNCPTR *DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-  extern void (CODEGEN_FUNCPTR *TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);
-  extern void (CODEGEN_FUNCPTR *PrimitiveRestartIndex)(GLuint index);
-
-  // Legacy
-  enum
-  {
-    VERTEX_ARRAY = 0x8074,
-    NORMAL_ARRAY = 0x8075,
-    COLOR_ARRAY = 0x8076,
-    TEXTURE_COORD_ARRAY = 0x8078,
-
-    TEXTURE_ENV = 0x2300,
-    TEXTURE_ENV_MODE = 0x2200,
-
-    MODELVIEW = 0x1700,
-    PROJECTION = 0x1701,
-    LIGHTING = 0x0B50
-  };
-
-  extern void (CODEGEN_FUNCPTR *EnableClientState)(GLenum cap);
-  extern void (CODEGEN_FUNCPTR *DisableClientState)(GLenum cap);
-  extern void (CODEGEN_FUNCPTR *VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-  extern void (CODEGEN_FUNCPTR *NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr);
-  extern void (CODEGEN_FUNCPTR *ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-  extern void (CODEGEN_FUNCPTR *TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
-
-  extern void (CODEGEN_FUNCPTR *TexEnvi)(GLenum target, GLenum pname, GLint param);
-
-  extern void (CODEGEN_FUNCPTR *MatrixMode)(GLenum mode);
-  extern void (CODEGEN_FUNCPTR *LoadIdentity)(void);
-  extern void (CODEGEN_FUNCPTR *Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
-
-  extern void (CODEGEN_FUNCPTR *Color3d)(GLdouble red, GLdouble green, GLdouble blue);
-
-  namespace sys
-  {
-    void CheckExtensions();
-  }
+    // Legacy
+    extern void (CODEGEN_FUNCPTR *EnableClientState)(GLenum cap);
+    extern void (CODEGEN_FUNCPTR *DisableClientState)(GLenum cap);
+    extern void (CODEGEN_FUNCPTR *VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+    extern void (CODEGEN_FUNCPTR *NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr);
+    extern void (CODEGEN_FUNCPTR *ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+    extern void (CODEGEN_FUNCPTR *TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr);
+    extern void (CODEGEN_FUNCPTR *TexEnvi)(GLenum target, GLenum pname, GLint param);
+    extern void (CODEGEN_FUNCPTR *MatrixMode)(GLenum mode);
+    extern void (CODEGEN_FUNCPTR *LoadIdentity)(void);
+    extern void (CODEGEN_FUNCPTR *Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val);
+    extern void (CODEGEN_FUNCPTR *Color3d)(GLdouble red, GLdouble green, GLdouble blue);
 }
-#endif //OPENGL_NOLOAD_STYLE_HPP
+
+#endif // OPENGL_NOLOAD_STYLE_HPP
diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index e3ac95fac..add58a70e 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -327,7 +327,7 @@ public:
     static const Ptr<Impl>& empty();
 
     Impl(GLuint bufId, bool autoRelease);
-    Impl(GLsizeiptr size, const GLvoid* data, GLenum target);
+    Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease);
     ~Impl();
 
     void bind(GLenum target) const;
@@ -337,7 +337,7 @@ public:
     void copyFrom(GLsizeiptr size, const GLvoid* data);
     void copyTo(GLsizeiptr size, GLvoid* data) const;
 
-    void* mapHost();
+    void* mapHost(GLenum access);
     void unmapHost();
 
 #ifdef HAVE_CUDA
@@ -377,7 +377,7 @@ cv::GlBuffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), auto
 {
 }
 
-cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target) : bufId_(0), autoRelease_(true)
+cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target, bool autoRelease) : bufId_(0), autoRelease_(autoRelease)
 {
     gl::GenBuffers(1, &bufId_);
     CV_CheckGlError();
@@ -436,12 +436,12 @@ void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const
     CV_CheckGlError();
 }
 
-void* cv::GlBuffer::Impl::mapHost()
+void* cv::GlBuffer::Impl::mapHost(GLenum access)
 {
     gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_);
     CV_CheckGlError();
 
-    GLvoid* data = gl::MapBuffer(gl::COPY_READ_BUFFER, gl::READ_WRITE);
+    GLvoid* data = gl::MapBuffer(gl::COPY_READ_BUFFER, access);
     CV_CheckGlError();
 
     return data;
@@ -521,17 +521,17 @@ cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRele
 #endif
 }
 
-cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target) : rows_(0), cols_(0), type_(0)
+cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0)
 {
-    create(arows, acols, atype, target);
+    create(arows, acols, atype, target, autoRelease);
 }
 
-cv::GlBuffer::GlBuffer(Size asize, int atype, Target target) : rows_(0), cols_(0), type_(0)
+cv::GlBuffer::GlBuffer(Size asize, int atype, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0)
 {
-    create(asize, atype, target);
+    create(asize, atype, target, autoRelease);
 }
 
-cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type_(0)
+cv::GlBuffer::GlBuffer(InputArray arr, Target target, bool autoRelease) : rows_(0), cols_(0), type_(0)
 {
 #ifndef HAVE_OPENGL
     (void) arr;
@@ -544,19 +544,19 @@ cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type
     {
     case _InputArray::OPENGL_BUFFER:
         {
-            copyFrom(arr, target);
+            copyFrom(arr, target, autoRelease);
             break;
         }
 
     case _InputArray::OPENGL_TEXTURE2D:
         {
-            copyFrom(arr, target);
+            copyFrom(arr, target, autoRelease);
             break;
         }
 
     case _InputArray::GPU_MAT:
         {
-            copyFrom(arr, target);
+            copyFrom(arr, target, autoRelease);
             break;
         }
 
@@ -565,7 +565,7 @@ cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type
             Mat mat = arr.getMat();
             CV_Assert( mat.isContinuous() );
             const GLsizeiptr asize = mat.rows * mat.cols * mat.elemSize();
-            impl_ = new Impl(asize, mat.data, target);
+            impl_ = new Impl(asize, mat.data, target, autoRelease);
             rows_ = mat.rows;
             cols_ = mat.cols;
             type_ = mat.type();
@@ -575,7 +575,7 @@ cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type
 #endif
 }
 
-void cv::GlBuffer::create(int arows, int acols, int atype, Target target)
+void cv::GlBuffer::create(int arows, int acols, int atype, Target target, bool autoRelease)
 {
 #ifndef HAVE_OPENGL
     (void) arows;
@@ -587,7 +587,7 @@ void cv::GlBuffer::create(int arows, int acols, int atype, Target target)
     if (rows_ != arows || cols_ != acols || type_ != atype)
     {
         const GLsizeiptr asize = arows * acols * CV_ELEM_SIZE(atype);
-        impl_ = new Impl(asize, 0, target);
+        impl_ = new Impl(asize, 0, target, autoRelease);
         rows_ = arows;
         cols_ = acols;
         type_ = atype;
@@ -598,6 +598,8 @@ void cv::GlBuffer::create(int arows, int acols, int atype, Target target)
 void cv::GlBuffer::release()
 {
 #ifdef HAVE_OPENGL
+    if (*impl_.refcount == 1)
+        impl_->setAutoRelease(true);
     impl_ = Impl::empty();
     rows_ = 0;
     cols_ = 0;
@@ -615,7 +617,7 @@ void cv::GlBuffer::setAutoRelease(bool flag)
 #endif
 }
 
-void cv::GlBuffer::copyFrom(InputArray arr, Target target)
+void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease)
 {
 #ifndef HAVE_OPENGL
     (void) arr;
@@ -628,12 +630,13 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target)
     {
         GlTexture2D tex = arr.getGlTexture2D();
         tex.copyTo(*this);
+        setAutoRelease(autoRelease);
         return;
     }
 
     const Size asize = arr.size();
     const int atype = arr.type();
-    create(asize, atype, target);
+    create(asize, atype, target, autoRelease);
 
     switch (kind)
     {
@@ -747,13 +750,14 @@ void cv::GlBuffer::unbind(Target target)
 #endif
 }
 
-Mat cv::GlBuffer::mapHost()
+Mat cv::GlBuffer::mapHost(Access access)
 {
 #ifndef HAVE_OPENGL
+    (void) access;
     throw_nogl();
     return Mat();
 #else
-    return Mat(rows_, cols_, type_, impl_->mapHost());
+    return Mat(rows_, cols_, type_, impl_->mapHost(access));
 #endif
 }
 
@@ -826,7 +830,7 @@ public:
     static const Ptr<Impl> empty();
 
     Impl(GLuint texId, bool autoRelease);
-    Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
+    Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease);
     ~Impl();
 
     void copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
@@ -859,7 +863,7 @@ cv::GlTexture2D::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), a
 {
 }
 
-cv::GlTexture2D::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) : texId_(0), autoRelease_(true)
+cv::GlTexture2D::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels, bool autoRelease) : texId_(0), autoRelease_(autoRelease)
 {
     gl::GenTextures(1, &texId_);
     CV_CheckGlError();
@@ -962,17 +966,17 @@ cv::GlTexture2D::GlTexture2D(Size asize, Format aformat, unsigned int atexId, bo
 #endif
 }
 
-cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat) : rows_(0), cols_(0), format_(NONE)
+cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
 {
-    create(arows, acols, aformat);
+    create(arows, acols, aformat, autoRelease);
 }
 
-cv::GlTexture2D::GlTexture2D(Size asize, Format aformat) : rows_(0), cols_(0), format_(NONE)
+cv::GlTexture2D::GlTexture2D(Size asize, Format aformat, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
 {
-    create(asize, aformat);
+    create(asize, aformat, autoRelease);
 }
 
-cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
+cv::GlTexture2D::GlTexture2D(InputArray arr, bool autoRelease) : rows_(0), cols_(0), format_(NONE)
 {
 #ifndef HAVE_OPENGL
     (void) arr;
@@ -1004,7 +1008,7 @@ cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
         {
             GlBuffer buf = arr.getGlBuffer();
             buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
-            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease);
             GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             break;
         }
@@ -1017,7 +1021,7 @@ cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
                 GpuMat dmat = arr.getGpuMat();
                 GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER);
                 buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER);
-                impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0);
+                impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0, autoRelease);
                 GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
             #endif
 
@@ -1029,7 +1033,7 @@ cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
             Mat mat = arr.getMat();
             CV_Assert( mat.isContinuous() );
             GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
-            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data);
+            impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data, autoRelease);
             break;
         }
     }
@@ -1040,7 +1044,7 @@ cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE)
 #endif
 }
 
-void cv::GlTexture2D::create(int arows, int acols, Format aformat)
+void cv::GlTexture2D::create(int arows, int acols, Format aformat, bool autoRelease)
 {
 #ifndef HAVE_OPENGL
     (void) arows;
@@ -1051,7 +1055,7 @@ void cv::GlTexture2D::create(int arows, int acols, Format aformat)
     if (rows_ != arows || cols_ != acols || format_ != aformat)
     {
         GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER);
-        impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0);
+        impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0, autoRelease);
         rows_ = arows;
         cols_ = acols;
         format_ = aformat;
@@ -1062,6 +1066,8 @@ void cv::GlTexture2D::create(int arows, int acols, Format aformat)
 void cv::GlTexture2D::release()
 {
 #ifdef HAVE_OPENGL
+    if (*impl_.refcount == 1)
+        impl_->setAutoRelease(true);
     impl_ = Impl::empty();
     rows_ = 0;
     cols_ = 0;
@@ -1079,7 +1085,7 @@ void cv::GlTexture2D::setAutoRelease(bool flag)
 #endif
 }
 
-void cv::GlTexture2D::copyFrom(InputArray arr)
+void cv::GlTexture2D::copyFrom(InputArray arr, bool autoRelease)
 {
 #ifndef HAVE_OPENGL
     (void) arr;
@@ -1105,7 +1111,7 @@ void cv::GlTexture2D::copyFrom(InputArray arr)
         0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA
     };
 
-    create(asize, internalFormats[cn]);
+    create(asize, internalFormats[cn], autoRelease);
 
     switch(kind)
     {
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index bbb10e1e3..990027b40 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -351,14 +351,14 @@ TEST_P(GlBuffer, Clone)
     cv::destroyAllWindows();
 }
 
-TEST_P(GlBuffer, MapHost)
+TEST_P(GlBuffer, MapHostRead)
 {
     cv::namedWindow("test", cv::WINDOW_OPENGL);
 
     cv::Mat gold = randomMat(size, type);
     cv::GlBuffer buf(gold);
 
-    cv::Mat dst = buf.mapHost();
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
 
     EXPECT_MAT_NEAR(gold, dst, 0);
 
@@ -368,6 +368,27 @@ TEST_P(GlBuffer, MapHost)
     cv::destroyAllWindows();
 }
 
+TEST_P(GlBuffer, MapHostWrite)
+{
+    cv::namedWindow("test", cv::WINDOW_OPENGL);
+
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf(size, type);
+
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
+    gold.copyTo(dst);
+    buf.unmapHost();
+    dst.release();
+
+    cv::Mat bufData;
+    buf.copyTo(bufData);
+
+    EXPECT_MAT_NEAR(gold, bufData, 0);
+
+    buf.release();
+    cv::destroyAllWindows();
+}
+
 TEST_P(GlBuffer, MapDevice)
 {
     cv::namedWindow("test", cv::WINDOW_OPENGL);
diff --git a/samples/gpu/opengl.cpp b/samples/gpu/opengl.cpp
index acd59e294..ec6fbf879 100644
--- a/samples/gpu/opengl.cpp
+++ b/samples/gpu/opengl.cpp
@@ -56,14 +56,18 @@ void CV_CDECL draw(void* userdata)
 
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
-    gluLookAt(0, 0, 4, 0, 0, 0, 0, 1, 0);
+    gluLookAt(0, 0, 3, 0, 0, 0, 0, 1, 0);
     glRotated(angle, 0, 1, 0);
 
     glEnable(GL_TEXTURE_2D);
     data->tex.bind();
 
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexEnvi(GL_TEXTURE_2D, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+
     glDisable(GL_CULL_FACE);
-    glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
 
     render(data->arr, data->indices, RenderMode::TRIANGLES);
 
@@ -101,13 +105,8 @@ int main(int argc, char* argv[])
 
     data.arr.setVertexArray(vertex);
     data.arr.setTexCoordArray(texCoords);
-    data.arr.setAutoRelease(false);
-
     data.indices.copyFrom(indices);
-    data.indices.setAutoRelease(false);
-
     data.tex.copyFrom(img);
-    data.tex.setAutoRelease(false);
 
     setOpenGlDrawCallback("OpenGL", draw, &data);
 

From 06776b612c16c4a6dd247a57de274116da38fbb5 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 3 Dec 2012 13:27:20 +0400
Subject: [PATCH 112/155] fixed warnings

---
 modules/core/src/opengl_interop.cpp | 6 ++++++
 modules/gpu/perf/perf_core.cpp      | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index add58a70e..9992cb0aa 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -536,6 +536,7 @@ cv::GlBuffer::GlBuffer(InputArray arr, Target target, bool autoRelease) : rows_(
 #ifndef HAVE_OPENGL
     (void) arr;
     (void) target;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
@@ -582,6 +583,7 @@ void cv::GlBuffer::create(int arows, int acols, int atype, Target target, bool a
     (void) acols;
     (void) atype;
     (void) target;
+    (void) autoRelease;
     throw_nogl();
 #else
     if (rows_ != arows || cols_ != acols || type_ != atype)
@@ -622,6 +624,7 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease)
 #ifndef HAVE_OPENGL
     (void) arr;
     (void) target;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
@@ -980,6 +983,7 @@ cv::GlTexture2D::GlTexture2D(InputArray arr, bool autoRelease) : rows_(0), cols_
 {
 #ifndef HAVE_OPENGL
     (void) arr;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
@@ -1050,6 +1054,7 @@ void cv::GlTexture2D::create(int arows, int acols, Format aformat, bool autoRele
     (void) arows;
     (void) acols;
     (void) aformat;
+    (void) autoRelease;
     throw_nogl();
 #else
     if (rows_ != arows || cols_ != acols || format_ != aformat)
@@ -1089,6 +1094,7 @@ void cv::GlTexture2D::copyFrom(InputArray arr, bool autoRelease)
 {
 #ifndef HAVE_OPENGL
     (void) arr;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index 1befcf929..ad722fa3b 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -1859,7 +1859,7 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
     cv::Mat src(size, depth);
     fillRandom(src);
 
-    int dst;
+    int dst = 0;
 
     if (PERF_RUN_GPU())
     {

From 7ab9c4ccee4a068dbd6c1fe7489152bd5ae7e17b Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 4 Dec 2012 10:36:46 +0400
Subject: [PATCH 113/155] fixed compilation on 1.1 CC

---
 modules/gpu/src/cuda/icf-sc.cu | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 5fca87b4d..9f1661c63 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -114,7 +114,9 @@ namespace icf {
                     excluded = excluded || (suppessed == i);
                 }
 
+            #if __CUDA_ARCH__ >= 120
                 if (__all(excluded)) break;
+            #endif
             }
         }
     }
@@ -312,7 +314,9 @@ __device void CascadeInvoker<Policy>::detect(Detection* objects, const uint ndet
         PrefixSum<Policy>::apply(impact);
         confidence += impact;
 
+    #if __CUDA_ARCH__ >= 120
         if(__any((confidence <= stages[(st + threadIdx.x)]))) st += 2048;
+    #endif
     }
 
     if(!threadIdx.x && st == stEnd &&  ((confidence - FLT_EPSILON) >= 0))
@@ -367,4 +371,4 @@ template void CascadeInvoker<GK107PolicyX4>::operator()(const PtrStepSzb& roi, c
     PtrStepSz<uchar4> objects, const int downscales, const cudaStream_t& stream) const;
 
 }
-}}}
\ No newline at end of file
+}}}

From e311613fc8985e036e0a3a0287575684e0db96ce Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 4 Dec 2012 10:37:13 +0400
Subject: [PATCH 114/155] fixed warnings "double not supported"

---
 modules/gpu/src/cuda/mathfunc.cu     |  8 ++++----
 modules/gpu/src/cuda/optical_flow.cu | 22 +++++++++++-----------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/modules/gpu/src/cuda/mathfunc.cu b/modules/gpu/src/cuda/mathfunc.cu
index 516ea37a8..3ae8fdc7b 100644
--- a/modules/gpu/src/cuda/mathfunc.cu
+++ b/modules/gpu/src/cuda/mathfunc.cu
@@ -76,7 +76,7 @@ namespace cv { namespace gpu { namespace device
             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;
+                angle += (angle < 0) * 2.0f * CV_PI_F;
                 dst[y * dst_step + x] = scale * angle;
             }
         };
@@ -140,7 +140,7 @@ namespace cv { namespace gpu { namespace device
             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;
+            const float scale = angleInDegrees ? (180.0f / CV_PI_F) : 1.f;
 
             cartToPolar<Mag, Angle><<<grid, threads, 0, stream>>>(
                 x.data, x.step/x.elemSize(), y.data, y.step/y.elemSize(),
@@ -190,7 +190,7 @@ namespace cv { namespace gpu { namespace device
             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;
+            const float scale = angleInDegrees ? (CV_PI_F / 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);
@@ -214,4 +214,4 @@ namespace cv { namespace gpu { namespace device
     } // namespace mathfunc
 }}} // namespace cv { namespace gpu { namespace device
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/optical_flow.cu b/modules/gpu/src/cuda/optical_flow.cu
index 0c8d140f9..d2c68a79f 100644
--- a/modules/gpu/src/cuda/optical_flow.cu
+++ b/modules/gpu/src/cuda/optical_flow.cu
@@ -164,40 +164,40 @@ namespace cv { namespace gpu { namespace device
 
                 r = ::fmin(r, 2.5f);
 
-                v[1].x = arrow_x + r * ::cosf(theta - CV_PI / 2.0f);
-                v[1].y = arrow_y + r * ::sinf(theta - CV_PI / 2.0f);
+                v[1].x = arrow_x + r * ::cosf(theta - CV_PI_F / 2.0f);
+                v[1].y = arrow_y + r * ::sinf(theta - CV_PI_F / 2.0f);
 
-                v[4].x = arrow_x + r * ::cosf(theta + CV_PI / 2.0f);
-                v[4].y = arrow_y + r * ::sinf(theta + CV_PI / 2.0f);
+                v[4].x = arrow_x + r * ::cosf(theta + CV_PI_F / 2.0f);
+                v[4].y = arrow_y + r * ::sinf(theta + CV_PI_F / 2.0f);
 
                 int indx = (y * u_avg.cols + x) * NUM_VERTS_PER_ARROW * 3;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[0].x * xscale;
                 vertex_data[indx++] = v[0].y * yscale;
                 vertex_data[indx++] = v[0].z;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[1].x * xscale;
                 vertex_data[indx++] = v[1].y * yscale;
                 vertex_data[indx++] = v[1].z;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[2].x * xscale;
                 vertex_data[indx++] = v[2].y * yscale;
                 vertex_data[indx++] = v[2].z;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[3].x * xscale;
                 vertex_data[indx++] = v[3].y * yscale;
                 vertex_data[indx++] = v[3].z;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[4].x * xscale;
                 vertex_data[indx++] = v[4].y * yscale;
                 vertex_data[indx++] = v[4].z;
 
-                color_data[indx] = (theta - CV_PI) / CV_PI * 180.0f;
+                color_data[indx] = (theta - CV_PI_F) / CV_PI_F * 180.0f;
                 vertex_data[indx++] = v[5].x * xscale;
                 vertex_data[indx++] = v[5].y * yscale;
                 vertex_data[indx++] = v[5].z;
@@ -217,4 +217,4 @@ namespace cv { namespace gpu { namespace device
     }
 }}}
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */

From aabc33c7724fa7ebc0546012efa4fafc8fc1278d Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 10:36:54 +0400
Subject: [PATCH 115/155] temporarily disabled reduceKeyVal implementation for
 kepler

used fermi implementation
---
 .../include/opencv2/gpu/device/detail/reduce_key_val.hpp    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
index ca2c43127..a84e0c2fd 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/reduce_key_val.hpp
@@ -399,7 +399,7 @@ namespace cv { namespace gpu { namespace device
             template <class KP, class KR, class VP, class VR, class Cmp>
             static __device__ void reduce(KP skeys, KR key, VP svals, VR val, unsigned int tid, Cmp cmp)
             {
-            #if __CUDA_ARCH__ >= 300
+            #if 0 // __CUDA_ARCH__ >= 300
                 (void) skeys;
                 (void) svals;
                 (void) tid;
@@ -424,7 +424,7 @@ namespace cv { namespace gpu { namespace device
             {
                 const unsigned int laneId = Warp::laneId();
 
-            #if __CUDA_ARCH__ >= 300
+            #if 0 // __CUDA_ARCH__ >= 300
                 Unroll<16, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, warpSize);
 
                 if (laneId == 0)
@@ -454,7 +454,7 @@ namespace cv { namespace gpu { namespace device
 
                 if (tid < 32)
                 {
-                #if __CUDA_ARCH__ >= 300
+                #if 0 // __CUDA_ARCH__ >= 300
                     loadFromSmem(svals, val, tid);
 
                     Unroll<M / 2, KP, KR, VP, VR, Cmp>::loopShfl(key, val, cmp, M);

From b689eca8a0a0bf45edb30d240a06e15389d2c245 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 14:18:57 +0400
Subject: [PATCH 116/155] fixed OpenGL tests

now create window only once per test case
---
 .../include/opencv2/core/opengl_interop.hpp   |   6 +-
 modules/core/src/opengl_interop.cpp           |  17 +-
 modules/gpu/test/test_opengl.cpp              | 272 +++++-------------
 3 files changed, 80 insertions(+), 215 deletions(-)

diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp
index cda1a8b5d..cfa84756c 100644
--- a/modules/core/include/opencv2/core/opengl_interop.hpp
+++ b/modules/core/include/opencv2/core/opengl_interop.hpp
@@ -106,10 +106,10 @@ public:
     void copyFrom(InputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false);
 
     //! copy to host/device memory
-    void copyTo(OutputArray arr, Target target = ARRAY_BUFFER) const;
+    void copyTo(OutputArray arr, Target target = ARRAY_BUFFER, bool autoRelease = false) const;
 
     //! create copy of current buffer
-    GlBuffer clone(Target target = ARRAY_BUFFER) const;
+    GlBuffer clone(Target target = ARRAY_BUFFER, bool autoRelease = false) const;
 
     //! bind buffer for specified target
     void bind(Target target) const;
@@ -189,7 +189,7 @@ public:
     void copyFrom(InputArray arr, bool autoRelease = false);
 
     //! copy to host/device memory
-    void copyTo(OutputArray arr, int ddepth = CV_32F) const;
+    void copyTo(OutputArray arr, int ddepth = CV_32F, bool autoRelease = false) const;
 
     //! bind texture to current active texture unit for GL_TEXTURE_2D target
     void bind() const;
diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index 9992cb0aa..64739792a 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -672,11 +672,12 @@ void cv::GlBuffer::copyFrom(InputArray arr, Target target, bool autoRelease)
 #endif
 }
 
-void cv::GlBuffer::copyTo(OutputArray arr, Target target) const
+void cv::GlBuffer::copyTo(OutputArray arr, Target target, bool autoRelease) const
 {
 #ifndef HAVE_OPENGL
     (void) arr;
     (void) target;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
@@ -685,13 +686,13 @@ void cv::GlBuffer::copyTo(OutputArray arr, Target target) const
     {
     case _InputArray::OPENGL_BUFFER:
         {
-            arr.getGlBufferRef().copyFrom(*this, target);
+            arr.getGlBufferRef().copyFrom(*this, target, autoRelease);
             break;
         }
 
     case _InputArray::OPENGL_TEXTURE2D:
         {
-            arr.getGlTexture2DRef().copyFrom(*this);
+            arr.getGlTexture2DRef().copyFrom(*this, autoRelease);
             break;
         }
 
@@ -719,15 +720,16 @@ void cv::GlBuffer::copyTo(OutputArray arr, Target target) const
 #endif
 }
 
-GlBuffer cv::GlBuffer::clone(Target target) const
+GlBuffer cv::GlBuffer::clone(Target target, bool autoRelease) const
 {
 #ifndef HAVE_OPENGL
     (void) target;
+    (void) autoRelease;
     throw_nogl();
     return GlBuffer();
 #else
     GlBuffer buf;
-    buf.copyFrom(*this, target);
+    buf.copyFrom(*this, target, autoRelease);
     return buf;
 #endif
 }
@@ -1156,11 +1158,12 @@ void cv::GlTexture2D::copyFrom(InputArray arr, bool autoRelease)
 #endif
 }
 
-void cv::GlTexture2D::copyTo(OutputArray arr, int ddepth) const
+void cv::GlTexture2D::copyTo(OutputArray arr, int ddepth, bool autoRelease) const
 {
 #ifndef HAVE_OPENGL
     (void) arr;
     (void) ddepth;
+    (void) autoRelease;
     throw_nogl();
 #else
     const int kind = arr.kind();
@@ -1173,7 +1176,7 @@ void cv::GlTexture2D::copyTo(OutputArray arr, int ddepth) const
     case _InputArray::OPENGL_BUFFER:
         {
             GlBuffer& buf = arr.getGlBufferRef();
-            buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER);
+            buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER, autoRelease);
             buf.bind(GlBuffer::PIXEL_PACK_BUFFER);
             impl_->copyTo(dstFormat, gl_types[ddepth], 0);
             GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER);
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index 990027b40..3bb3e09ea 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -48,6 +48,16 @@
 
 PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
 {
+    static void SetUpTestCase()
+    {
+        cv::namedWindow("test", cv::WINDOW_OPENGL);
+    }
+
+    static void TearDownTestCase()
+    {
+        cv::destroyAllWindows();
+    }
+
     cv::Size size;
     int type;
 
@@ -60,83 +70,57 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
 
 TEST_P(GlBuffer, Constructor1)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
-    cv::GlBuffer buf(size.height, size.width, type);
+    cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_EQ(size.height, buf.rows());
     EXPECT_EQ(size.width, buf.cols());
     EXPECT_EQ(type, buf.type());
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, Constructor2)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
-    cv::GlBuffer buf(size, type);
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_EQ(size.height, buf.rows());
     EXPECT_EQ(size.width, buf.cols());
     EXPECT_EQ(type, buf.type());
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, ConstructorFromMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, ConstructorFromGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
     cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlBuffer buf(d_gold);
+    cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    d_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, ConstructorFromGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
+    cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::GlBuffer buf_gold(size, type);
     cv::GlBuffer buf(buf_gold);
 
     EXPECT_EQ(buf_gold.bufId(), buf.bufId());
     EXPECT_EQ(buf_gold.rows(), buf.rows());
     EXPECT_EQ(buf_gold.cols(), buf.cols());
     EXPECT_EQ(buf_gold.type(), buf.type());
-
-    buf.release();
-    buf_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, ConstructorFromGlTexture2D)
@@ -147,85 +131,61 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D)
     if (depth != CV_32F || cn == 2)
         return;
 
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, 1.0);
-    cv::GlTexture2D tex_gold(gold);
+    cv::GlTexture2D tex_gold(gold, true);
 
-    cv::GlBuffer buf(tex_gold);
+    cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-
-    buf.release();
-    tex_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, Create)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::GlBuffer buf;
-    buf.create(size.height, size.width, type);
+    buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_EQ(size.height, buf.rows());
     EXPECT_EQ(size.width, buf.cols());
     EXPECT_EQ(type, buf.type());
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyFromMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
 
     cv::GlBuffer buf;
-    buf.copyFrom(gold);
+    buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyFromGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
     cv::gpu::GpuMat d_gold(gold);
 
     cv::GlBuffer buf;
-    buf.copyFrom(d_gold);
+    buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    d_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyFromGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf_gold(gold);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::GlBuffer buf;
-    buf.copyFrom(buf_gold);
+    buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_NE(buf_gold.bufId(), buf.bufId());
 
@@ -233,10 +193,6 @@ TEST_P(GlBuffer, CopyFromGlBuffer)
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    buf_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyFromGlTexture2D)
@@ -247,50 +203,38 @@ TEST_P(GlBuffer, CopyFromGlTexture2D)
     if (depth != CV_32F || cn == 2)
         return;
 
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, 1.0);
-    cv::GlTexture2D tex_gold(gold);
+    cv::GlTexture2D tex_gold(gold, true);
 
     cv::GlBuffer buf;
-    buf.copyFrom(tex_gold);
+    buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat bufData;
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-
-    buf.release();
-    tex_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyToGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+
     cv::gpu::GpuMat dst;
     buf.copyTo(dst);
 
     EXPECT_MAT_NEAR(gold, dst, 0);
-
-    dst.release();
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyToGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::GlBuffer dst;
-    buf.copyTo(dst);
+    buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_NE(buf.bufId(), dst.bufId());
 
@@ -298,10 +242,6 @@ TEST_P(GlBuffer, CopyToGlBuffer)
     dst.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    dst.release();
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, CopyToGlTexture2D)
@@ -312,32 +252,26 @@ TEST_P(GlBuffer, CopyToGlTexture2D)
     if (depth != CV_32F || cn == 2)
         return;
 
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, 1.0);
-    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
     cv::GlTexture2D tex;
-    buf.copyTo(tex);
+    buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
     cv::Mat texData;
     tex.copyTo(texData);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, Clone)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf(gold);
 
-    cv::GlBuffer dst = buf.clone();
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+
+    cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
 
     EXPECT_NE(buf.bufId(), dst.bufId());
 
@@ -345,35 +279,26 @@ TEST_P(GlBuffer, Clone)
     dst.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    dst.release();
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, MapHostRead)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
 
     EXPECT_MAT_NEAR(gold, dst, 0);
 
     buf.unmapHost();
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, MapHostWrite)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf(size, type);
+
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
     gold.copyTo(dst);
@@ -384,26 +309,19 @@ TEST_P(GlBuffer, MapHostWrite)
     buf.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 0);
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlBuffer, MapDevice)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf(gold);
+
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
     cv::gpu::GpuMat dst = buf.mapDevice();
 
     EXPECT_MAT_NEAR(gold, dst, 0);
 
     buf.unmapDevice();
-
-    buf.release();
-    cv::destroyAllWindows();
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@@ -413,6 +331,16 @@ INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_
 
 PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
 {
+    static void SetUpTestCase()
+    {
+        cv::namedWindow("test", cv::WINDOW_OPENGL);
+    }
+
+    static void TearDownTestCase()
+    {
+        cv::destroyAllWindows();
+    }
+
     cv::Size size;
     int type;
     int depth;
@@ -432,213 +360,147 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
 
 TEST_P(GlTexture2D, Constructor1)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
-    cv::GlTexture2D tex(size.height, size.width, format);
+    cv::GlTexture2D tex(size.height, size.width, format, true);
 
     EXPECT_EQ(size.height, tex.rows());
     EXPECT_EQ(size.width, tex.cols());
     EXPECT_EQ(format, tex.format());
-
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, Constructor2)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
-    cv::GlTexture2D tex(size, format);
+    cv::GlTexture2D tex(size, format, true);
 
     EXPECT_EQ(size.height, tex.rows());
     EXPECT_EQ(size.width, tex.cols());
     EXPECT_EQ(format, tex.format());
-
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, ConstructorFromMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold);
+    cv::GlTexture2D tex(gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, ConstructorFromGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlTexture2D tex(d_gold);
+    cv::GlTexture2D tex(d_gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    d_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::GlBuffer buf_gold(gold);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-    cv::GlTexture2D tex(buf_gold);
+    cv::GlTexture2D tex(buf_gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    buf_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
-    cv::GlTexture2D tex_gold(size, format);
+    cv::GlTexture2D tex_gold(size, format, true);
     cv::GlTexture2D tex(tex_gold);
 
     EXPECT_EQ(tex_gold.texId(), tex.texId());
     EXPECT_EQ(tex_gold.rows(), tex.rows());
     EXPECT_EQ(tex_gold.cols(), tex.cols());
     EXPECT_EQ(tex_gold.format(), tex.format());
-
-    tex.release();
-    tex_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, Create)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::GlTexture2D tex;
-    tex.create(size.height, size.width, format);
+    tex.create(size.height, size.width, format, true);
 
     EXPECT_EQ(size.height, tex.rows());
     EXPECT_EQ(size.width, tex.cols());
     EXPECT_EQ(format, tex.format());
-
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, CopyFromMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
     cv::GlTexture2D tex;
-    tex.copyFrom(gold);
+    tex.copyFrom(gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, CopyFromGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::gpu::GpuMat d_gold(gold);
 
     cv::GlTexture2D tex;
-    tex.copyFrom(d_gold);
+    tex.copyFrom(d_gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    d_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, CopyFromGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::GlBuffer buf_gold(gold);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
     cv::GlTexture2D tex;
-    tex.copyFrom(buf_gold);
+    tex.copyFrom(buf_gold, true);
 
     cv::Mat texData;
     tex.copyTo(texData, depth);
 
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
-
-    tex.release();
-    buf_gold.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, CopyToGpuMat)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold);
+    cv::GlTexture2D tex(gold, true);
+
     cv::gpu::GpuMat dst;
     tex.copyTo(dst, depth);
 
     EXPECT_MAT_NEAR(gold, dst, 1e-2);
-
-    dst.release();
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 TEST_P(GlTexture2D, CopyToGlBuffer)
 {
-    cv::namedWindow("test", cv::WINDOW_OPENGL);
-
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold);
+    cv::GlTexture2D tex(gold, true);
 
     cv::GlBuffer dst;
-    tex.copyTo(dst, depth);
+    tex.copyTo(dst, depth, true);
 
     cv::Mat bufData;
     dst.copyTo(bufData);
 
     EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-
-    dst.release();
-    tex.release();
-    cv::destroyAllWindows();
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));

From d94f08f0e780bafb7f31b4e77fedf2588d820f35 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 14:19:36 +0400
Subject: [PATCH 117/155] added more types support for gpu separable filters

---
 modules/gpu/src/cuda/column_filter.10.cu |  53 +++++++++
 modules/gpu/src/cuda/column_filter.11.cu |  53 +++++++++
 modules/gpu/src/cuda/column_filter.12.cu |  53 +++++++++
 modules/gpu/src/cuda/column_filter.13.cu |  53 +++++++++
 modules/gpu/src/cuda/column_filter.14.cu |  53 +++++++++
 modules/gpu/src/cuda/column_filter.8.cu  |  53 +++++++++
 modules/gpu/src/cuda/column_filter.9.cu  |  53 +++++++++
 modules/gpu/src/cuda/row_filter.10.cu    |  53 +++++++++
 modules/gpu/src/cuda/row_filter.11.cu    |  53 +++++++++
 modules/gpu/src/cuda/row_filter.12.cu    |  53 +++++++++
 modules/gpu/src/cuda/row_filter.13.cu    |  53 +++++++++
 modules/gpu/src/cuda/row_filter.14.cu    |  53 +++++++++
 modules/gpu/src/cuda/row_filter.8.cu     |  53 +++++++++
 modules/gpu/src/cuda/row_filter.9.cu     |  53 +++++++++
 modules/gpu/src/filtering.cpp            | 138 +++++++++--------------
 modules/gpu/test/test_filters.cpp        |  69 ++++++++----
 16 files changed, 842 insertions(+), 107 deletions(-)
 create mode 100644 modules/gpu/src/cuda/column_filter.10.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.11.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.12.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.13.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.14.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.8.cu
 create mode 100644 modules/gpu/src/cuda/column_filter.9.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.10.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.11.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.12.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.13.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.14.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.8.cu
 create mode 100644 modules/gpu/src/cuda/row_filter.9.cu

diff --git a/modules/gpu/src/cuda/column_filter.10.cu b/modules/gpu/src/cuda/column_filter.10.cu
new file mode 100644
index 000000000..41e35bc1c
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.10.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float, unsigned short>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.11.cu b/modules/gpu/src/cuda/column_filter.11.cu
new file mode 100644
index 000000000..981208a68
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.11.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float3, ushort3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.12.cu b/modules/gpu/src/cuda/column_filter.12.cu
new file mode 100644
index 000000000..13d2e6002
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.12.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float4, ushort4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.13.cu b/modules/gpu/src/cuda/column_filter.13.cu
new file mode 100644
index 000000000..09f6484af
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.13.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float3, int3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.14.cu b/modules/gpu/src/cuda/column_filter.14.cu
new file mode 100644
index 000000000..901ab0301
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.14.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float4, int4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.8.cu b/modules/gpu/src/cuda/column_filter.8.cu
new file mode 100644
index 000000000..38e70e772
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.8.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float, short>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.9.cu b/modules/gpu/src/cuda/column_filter.9.cu
new file mode 100644
index 000000000..5b5834582
--- /dev/null
+++ b/modules/gpu/src/cuda/column_filter.9.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "column_filter.h"
+
+namespace filter
+{
+    template void linearColumn<float4, short4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.10.cu b/modules/gpu/src/cuda/row_filter.10.cu
new file mode 100644
index 000000000..4509fe4a7
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.10.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<unsigned short, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.11.cu b/modules/gpu/src/cuda/row_filter.11.cu
new file mode 100644
index 000000000..839b56c7c
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.11.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<ushort3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.12.cu b/modules/gpu/src/cuda/row_filter.12.cu
new file mode 100644
index 000000000..c4879dbe4
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.12.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<ushort4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.13.cu b/modules/gpu/src/cuda/row_filter.13.cu
new file mode 100644
index 000000000..c5da957a5
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.13.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<int3, float3>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.14.cu b/modules/gpu/src/cuda/row_filter.14.cu
new file mode 100644
index 000000000..d8ccb9a2e
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.14.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<int4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.8.cu b/modules/gpu/src/cuda/row_filter.8.cu
new file mode 100644
index 000000000..77e4ed63f
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.8.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<short, float>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/row_filter.9.cu b/modules/gpu/src/cuda/row_filter.9.cu
new file mode 100644
index 000000000..954944b00
--- /dev/null
+++ b/modules/gpu/src/cuda/row_filter.9.cu
@@ -0,0 +1,53 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Copyright (C) 1993-2011, NVIDIA Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "row_filter.h"
+
+namespace filter
+{
+    template void linearRow<short4, float4>(PtrStepSzb src, PtrStepSzb dst, const float* kernel, int ksize, int anchor, int brd_type, int cc, cudaStream_t stream);
+}
+
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/filtering.cpp b/modules/gpu/src/filtering.cpp
index 6b7135ab6..8905eaed6 100644
--- a/modules/gpu/src/filtering.cpp
+++ b/modules/gpu/src/filtering.cpp
@@ -893,70 +893,56 @@ namespace
 
 Ptr<BaseRowFilter_GPU> cv::gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor, int borderType)
 {
-    static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterRow_8u_C1R, 0, 0, nppiFilterRow_8u_C4R};
+    static const gpuFilter1D_t funcs[7][4] =
+    {
+        {filter::linearRow<uchar, float>, 0, filter::linearRow<uchar3, float3>, filter::linearRow<uchar4, float4>},
+        {0, 0, 0, 0},
+        {filter::linearRow<ushort, float>, 0, filter::linearRow<ushort3, float3>, filter::linearRow<ushort4, float4>},
+        {filter::linearRow<short, float>, 0, filter::linearRow<short3, float3>, filter::linearRow<short4, float4>},
+        {filter::linearRow<int, float>, 0, filter::linearRow<int3, float3>, filter::linearRow<int4, float4>},
+        {filter::linearRow<float, float>, 0, filter::linearRow<float3, float3>, filter::linearRow<float4, float4>},
+        {0, 0, 0, 0}
+    };
+    static const nppFilter1D_t npp_funcs[] =
+    {
+        0, nppiFilterRow_8u_C1R, 0, 0, nppiFilterRow_8u_C4R
+    };
 
     if ((bufType == srcType) && (srcType == CV_8UC1 || srcType == CV_8UC4))
     {
-        CV_Assert(borderType == BORDER_CONSTANT);
+        CV_Assert( borderType == BORDER_CONSTANT );
 
         GpuMat gpu_row_krnl;
         int nDivisor;
         normalizeKernel(rowKernel, gpu_row_krnl, CV_32S, &nDivisor, true);
 
-        int ksize = gpu_row_krnl.cols;
+        const int ksize = gpu_row_krnl.cols;
         normalizeAnchor(anchor, ksize);
 
-        return Ptr<BaseRowFilter_GPU>(new NppLinearRowFilter(ksize, anchor, gpu_row_krnl, nDivisor,
-            nppFilter1D_callers[CV_MAT_CN(srcType)]));
+        return Ptr<BaseRowFilter_GPU>(new NppLinearRowFilter(ksize, anchor, gpu_row_krnl, nDivisor, npp_funcs[CV_MAT_CN(srcType)]));
     }
 
-    CV_Assert(borderType == BORDER_REFLECT101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP);
+    CV_Assert( borderType == BORDER_REFLECT101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP );
+
     int gpuBorderType;
-    CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
+    CV_Assert( tryConvertToGpuBorderType(borderType, gpuBorderType) );
 
-    CV_Assert(srcType == CV_8UC1 || srcType == CV_8UC3 || srcType == CV_8UC4 || srcType == CV_16SC3 || srcType == CV_32SC1 || srcType == CV_32FC1 || srcType == CV_32FC3 || srcType == CV_32FC4);
+    const int sdepth = CV_MAT_DEPTH(srcType);
+    const int cn = CV_MAT_CN(srcType);
+    CV_Assert( sdepth <= CV_64F && cn <= 4 );
+    CV_Assert( CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(bufType) == cn );
 
-    CV_Assert(CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(srcType) == CV_MAT_CN(bufType));
+    const gpuFilter1D_t func = funcs[sdepth][cn - 1];
+    CV_Assert( func != 0 );
 
     GpuMat gpu_row_krnl;
     normalizeKernel(rowKernel, gpu_row_krnl, CV_32F);
 
-    int ksize = gpu_row_krnl.cols;
-
-    CV_Assert(ksize > 0 && ksize <= 32);
+    const int ksize = gpu_row_krnl.cols;
+    CV_Assert( ksize > 0 && ksize <= 32 );
 
     normalizeAnchor(anchor, ksize);
 
-    gpuFilter1D_t func = 0;
-
-    switch (srcType)
-    {
-    case CV_8UC1:
-        func = filter::linearRow<uchar, float>;
-        break;
-    case CV_8UC3:
-        func = filter::linearRow<uchar3, float3>;
-        break;
-    case CV_8UC4:
-        func = filter::linearRow<uchar4, float4>;
-        break;
-    case CV_16SC3:
-        func = filter::linearRow<short3, float3>;
-        break;
-    case CV_32SC1:
-        func = filter::linearRow<int, float>;
-        break;
-    case CV_32FC1:
-        func = filter::linearRow<float, float>;
-        break;
-    case CV_32FC3:
-        func = filter::linearRow<float3, float3>;
-        break;
-    case CV_32FC4:
-        func = filter::linearRow<float4, float4>;
-        break;
-    }
-
     return Ptr<BaseRowFilter_GPU>(new GpuLinearRowFilter(ksize, anchor, gpu_row_krnl, func, gpuBorderType));
 }
 
@@ -1012,70 +998,56 @@ namespace
 
 Ptr<BaseColumnFilter_GPU> cv::gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor, int borderType)
 {
-    static const nppFilter1D_t nppFilter1D_callers[] = {0, nppiFilterColumn_8u_C1R, 0, 0, nppiFilterColumn_8u_C4R};
+    static const gpuFilter1D_t funcs[7][4] =
+    {
+        {filter::linearColumn<float, uchar>, 0, filter::linearColumn<float3, uchar3>, filter::linearColumn<float4, uchar4>},
+        {0, 0, 0, 0},
+        {filter::linearColumn<float, ushort>, 0, filter::linearColumn<float3, ushort3>, filter::linearColumn<float4, ushort4>},
+        {filter::linearColumn<float, short>, 0, filter::linearColumn<float3, short3>, filter::linearColumn<float4, short4>},
+        {filter::linearColumn<float, int>, 0, filter::linearColumn<float3, int3>, filter::linearColumn<float4, int4>},
+        {filter::linearColumn<float, float>, 0, filter::linearColumn<float3, float3>, filter::linearColumn<float4, float4>},
+        {0, 0, 0, 0}
+    };
+    static const nppFilter1D_t npp_funcs[] =
+    {
+        0, nppiFilterColumn_8u_C1R, 0, 0, nppiFilterColumn_8u_C4R
+    };
 
     if ((bufType == dstType) && (bufType == CV_8UC1 || bufType == CV_8UC4))
     {
-        CV_Assert(borderType == BORDER_CONSTANT);
+        CV_Assert( borderType == BORDER_CONSTANT );
 
         GpuMat gpu_col_krnl;
         int nDivisor;
         normalizeKernel(columnKernel, gpu_col_krnl, CV_32S, &nDivisor, true);
 
-        int ksize = gpu_col_krnl.cols;
+        const int ksize = gpu_col_krnl.cols;
         normalizeAnchor(anchor, ksize);
 
-        return Ptr<BaseColumnFilter_GPU>(new NppLinearColumnFilter(ksize, anchor, gpu_col_krnl, nDivisor,
-            nppFilter1D_callers[CV_MAT_CN(bufType)]));
+        return Ptr<BaseColumnFilter_GPU>(new NppLinearColumnFilter(ksize, anchor, gpu_col_krnl, nDivisor, npp_funcs[CV_MAT_CN(bufType)]));
     }
 
-    CV_Assert(borderType == BORDER_REFLECT101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP);
+    CV_Assert( borderType == BORDER_REFLECT101 || borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT || borderType == BORDER_REFLECT || borderType == BORDER_WRAP );
+
     int gpuBorderType;
-    CV_Assert(tryConvertToGpuBorderType(borderType, gpuBorderType));
+    CV_Assert( tryConvertToGpuBorderType(borderType, gpuBorderType) );
 
-    CV_Assert(dstType == CV_8UC1 || dstType == CV_8UC3 || dstType == CV_8UC4 || dstType == CV_16SC3 || dstType == CV_32SC1 || dstType == CV_32FC1 || dstType == CV_32FC3 || dstType == CV_32FC4);
+    const int ddepth = CV_MAT_DEPTH(dstType);
+    const int cn = CV_MAT_CN(dstType);
+    CV_Assert( ddepth <= CV_64F && cn <= 4 );
+    CV_Assert( CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(bufType) == cn );
 
-    CV_Assert(CV_MAT_DEPTH(bufType) == CV_32F && CV_MAT_CN(dstType) == CV_MAT_CN(bufType));
+    gpuFilter1D_t func = funcs[ddepth][cn - 1];
+    CV_Assert( func != 0 );
 
     GpuMat gpu_col_krnl;
     normalizeKernel(columnKernel, gpu_col_krnl, CV_32F);
 
-    int ksize = gpu_col_krnl.cols;
-
+    const int ksize = gpu_col_krnl.cols;
     CV_Assert(ksize > 0 && ksize <= 32);
 
     normalizeAnchor(anchor, ksize);
 
-    gpuFilter1D_t func = 0;
-
-    switch (dstType)
-    {
-    case CV_8UC1:
-        func = filter::linearColumn<float, uchar>;
-        break;
-    case CV_8UC3:
-        func = filter::linearColumn<float3, uchar3>;
-        break;
-    case CV_8UC4:
-        func = filter::linearColumn<float4, uchar4>;
-        break;
-    case CV_16SC3:
-        func = filter::linearColumn<float3, short3>;
-        break;
-    case CV_32SC1:
-        func = filter::linearColumn<float, int>;
-        break;
-    case CV_32FC1:
-        func = filter::linearColumn<float, float>;
-        break;
-    case CV_32FC3:
-        func = filter::linearColumn<float3, float3>;
-        break;
-    case CV_32FC4:
-        func = filter::linearColumn<float4, float4>;
-        break;
-    }
-
     return Ptr<BaseColumnFilter_GPU>(new GpuLinearColumnFilter(ksize, anchor, gpu_col_krnl, func, gpuBorderType));
 }
 
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index bb070373e..92d6fc002 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -113,29 +113,35 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
 IMPLEMENT_PARAM_CLASS(Deriv_X, int)
 IMPLEMENT_PARAM_CLASS(Deriv_Y, int)
 
-PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi)
+PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
-    int type;
+    int depth;
+    int cn;
     cv::Size ksize;
     int dx;
     int dy;
     int borderType;
     bool useRoi;
 
+    int type;
+
     virtual void SetUp()
     {
         devInfo = GET_PARAM(0);
         size = GET_PARAM(1);
-        type = GET_PARAM(2);
-        ksize = GET_PARAM(3);
-        dx = GET_PARAM(4);
-        dy = GET_PARAM(5);
-        borderType = GET_PARAM(6);
-        useRoi = GET_PARAM(7);
+        depth = GET_PARAM(2);
+        cn = GET_PARAM(3);
+        ksize = GET_PARAM(4);
+        dx = GET_PARAM(5);
+        dy = GET_PARAM(6);
+        borderType = GET_PARAM(7);
+        useRoi = GET_PARAM(8);
 
         cv::gpu::setDevice(devInfo.deviceID());
+
+        type = CV_MAKE_TYPE(depth, cn);
     }
 };
 
@@ -158,7 +164,8 @@ TEST_P(Sobel, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+    IMAGE_CHANNELS,
     testing::Values(KSize(cv::Size(3, 3)), KSize(cv::Size(5, 5)), KSize(cv::Size(7, 7))),
     testing::Values(Deriv_X(0), Deriv_X(1), Deriv_X(2)),
     testing::Values(Deriv_Y(0), Deriv_Y(1), Deriv_Y(2)),
@@ -171,27 +178,33 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Scharr
 
-PARAM_TEST_CASE(Scharr, cv::gpu::DeviceInfo, cv::Size, MatType, Deriv_X, Deriv_Y, BorderType, UseRoi)
+PARAM_TEST_CASE(Scharr, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Deriv_X, Deriv_Y, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
-    int type;
+    int depth;
+    int cn;
     int dx;
     int dy;
     int borderType;
     bool useRoi;
 
+    int type;
+
     virtual void SetUp()
     {
         devInfo = GET_PARAM(0);
         size = GET_PARAM(1);
-        type = GET_PARAM(2);
-        dx = GET_PARAM(3);
-        dy = GET_PARAM(4);
-        borderType = GET_PARAM(5);
-        useRoi = GET_PARAM(6);
+        depth = GET_PARAM(2);
+        cn = GET_PARAM(3);
+        dx = GET_PARAM(4);
+        dy = GET_PARAM(5);
+        borderType = GET_PARAM(6);
+        useRoi = GET_PARAM(7);
 
         cv::gpu::setDevice(devInfo.deviceID());
+
+        type = CV_MAKE_TYPE(depth, cn);
     }
 };
 
@@ -214,7 +227,8 @@ TEST_P(Scharr, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+    IMAGE_CHANNELS,
     testing::Values(Deriv_X(0), Deriv_X(1)),
     testing::Values(Deriv_Y(0), Deriv_Y(1)),
     testing::Values(BorderType(cv::BORDER_REFLECT101),
@@ -226,25 +240,31 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // GaussianBlur
 
-PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, BorderType, UseRoi)
+PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
     cv::Size size;
-    int type;
+    int depth;
+    int cn;
     cv::Size ksize;
     int borderType;
     bool useRoi;
 
+    int type;
+
     virtual void SetUp()
     {
         devInfo = GET_PARAM(0);
         size = GET_PARAM(1);
-        type = GET_PARAM(2);
-        ksize = GET_PARAM(3);
-        borderType = GET_PARAM(4);
-        useRoi = GET_PARAM(5);
+        depth = GET_PARAM(2);
+        cn = GET_PARAM(3);
+        ksize = GET_PARAM(4);
+        borderType = GET_PARAM(5);
+        useRoi = GET_PARAM(6);
 
         cv::gpu::setDevice(devInfo.deviceID());
+
+        type = CV_MAKE_TYPE(depth, cn);
     }
 };
 
@@ -281,7 +301,8 @@ TEST_P(GaussianBlur, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_Filter, GaussianBlur, testing::Combine(
     ALL_DEVICES,
     DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4), MatType(CV_32FC1), MatType(CV_32FC3), MatType(CV_32FC4)),
+    testing::Values(MatDepth(CV_8U), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32F)),
+    IMAGE_CHANNELS,
     testing::Values(KSize(cv::Size(3, 3)),
                     KSize(cv::Size(5, 5)),
                     KSize(cv::Size(7, 7)),

From 0930ac497faa520b892e0382c0145b164ecd7e5c Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 14:20:18 +0400
Subject: [PATCH 118/155] removed type check in gpu::PyrLKOpticalFlow

not it support all depths
---
 modules/gpu/src/pyrlk.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/pyrlk.cpp b/modules/gpu/src/pyrlk.cpp
index 593e37cc6..d5debbe0b 100644
--- a/modules/gpu/src/pyrlk.cpp
+++ b/modules/gpu/src/pyrlk.cpp
@@ -112,7 +112,7 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next
     dim3 block, patch;
     calcPatchSize(winSize, block, patch, isDeviceArch11_);
 
-    CV_Assert(prevImg.type() == CV_8UC1 || prevImg.type() == CV_8UC3 || prevImg.type() == CV_8UC4);
+    CV_Assert(prevImg.channels() == 1 || prevImg.channels() == 3 || prevImg.channels() == 4);
     CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());
     CV_Assert(maxLevel >= 0);
     CV_Assert(winSize.width > 2 && winSize.height > 2);

From e17710c478b4ed67544a9ae5ffea5c5e6aa5967d Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 14:20:48 +0400
Subject: [PATCH 119/155] removed type check in gpu::FarnebackOpticalFlow

now it supports all depths
---
 modules/gpu/src/optical_flow_farneback.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/src/optical_flow_farneback.cpp b/modules/gpu/src/optical_flow_farneback.cpp
index 44edda474..3a0a912ac 100644
--- a/modules/gpu/src/optical_flow_farneback.cpp
+++ b/modules/gpu/src/optical_flow_farneback.cpp
@@ -209,7 +209,7 @@ void cv::gpu::FarnebackOpticalFlow::updateFlow_gaussianBlur(
 void cv::gpu::FarnebackOpticalFlow::operator ()(
         const GpuMat &frame0, const GpuMat &frame1, GpuMat &flowx, GpuMat &flowy, Stream &s)
 {
-    CV_Assert(frame0.type() == CV_8U && frame1.type() == CV_8U);
+    CV_Assert(frame0.channels() == 1 && frame1.channels() == 1);
     CV_Assert(frame0.size() == frame1.size());
     CV_Assert(polyN == 5 || polyN == 7);
     CV_Assert(!fastPyramids || std::abs(pyrScale - 0.5) < 1e-6);

From afa5809473acba14538315aa9176dc68d735b28a Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 5 Dec 2012 17:21:08 +0400
Subject: [PATCH 120/155] added additional performance tests

---
 modules/gpu/app/nv_perf_test/CMakeLists.txt   |  10 +
 modules/gpu/app/nv_perf_test/im1_1280x800.jpg | Bin 0 -> 143316 bytes
 modules/gpu/app/nv_perf_test/im2_1280x800.jpg | Bin 0 -> 143366 bytes
 modules/gpu/app/nv_perf_test/main.cpp         | 285 ++++++++++++++++++
 4 files changed, 295 insertions(+)
 create mode 100644 modules/gpu/app/nv_perf_test/CMakeLists.txt
 create mode 100644 modules/gpu/app/nv_perf_test/im1_1280x800.jpg
 create mode 100644 modules/gpu/app/nv_perf_test/im2_1280x800.jpg
 create mode 100644 modules/gpu/app/nv_perf_test/main.cpp

diff --git a/modules/gpu/app/nv_perf_test/CMakeLists.txt b/modules/gpu/app/nv_perf_test/CMakeLists.txt
new file mode 100644
index 000000000..0793b4493
--- /dev/null
+++ b/modules/gpu/app/nv_perf_test/CMakeLists.txt
@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 2.8.6)
+
+project(nv_perf_test)
+
+find_package(OpenCV REQUIRED)
+include_directories(${OpenCV_INCLUDE_DIR})
+
+add_executable(${PROJECT_NAME} main.cpp)
+
+target_link_libraries(${PROJECT_NAME} ${OpenCV_LIBS})
diff --git a/modules/gpu/app/nv_perf_test/im1_1280x800.jpg b/modules/gpu/app/nv_perf_test/im1_1280x800.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..bdbbd4aee95128fe0d296a50800c9cb95f31f568
GIT binary patch
literal 143316
zcmb5VWl$X76E3{C`!4S8!4~(x;<oJK5P}7FcMmM?VIjCX1Sb#(!Lz{~5`u;e@Czh(
z2$%m`^;X@l_nfNv(x-d6re@B0x}Rqr*B*BO<k}D|2mk{E1EBFV0gs!2=KvfmY;0^S
zoTm#84h}9JF+SeYAR{6oAf_Orq@*CDprE2=q@e=RgD5Cy*=XsRm{?d?sA$+Z*_k;R
znOT_s7X;(U6%QAW6d#|I8At(S{(l~i!vG3=ELI!<76v;2lL7;a0^{)$fC&J=z<J6R
z1MvS3Yz#~+99#e%KEab&g&cs1frX9nzlnu~g^5A(WCdVT;83!Os^C(w8@<E>iurJ;
z#$<sw%f+E~_!8~ZG+e&1+}R`G=f?BjpF%KT05Gxs?;8LxFacQDPtW1WC`JLm#QguF
zKgGw!`d=0pm=svp{|k@vzwkgYRUcds2UJ`lru=zU`~2eufcR<I(;5nZ5<u1&aijnb
zm}a_Rg4g@-pUN9vsAMpj7DdIqN9>X+OROrNP{}{c8*6M6j^zD@{u_NDBFsF9tlRXT
zh?tueP2@px^9cK`@V&s${}{XPr+I?81NEY9cn1G@)i0EzCy;h?)8fjxS*1UKzZ#I@
zA&feFJIv}WFdFd!ZQ1O4`?^<6`Bz`vpa$A<(CJ`iQkClCGKYs29@DCyM#a@X<C8<z
z0LvlKAL+KC6@Q#myv27DbGSM*So|S{ZC04-0Wa5Q9Z_QypQ|R~U_F6QVJ#+;#MM1+
zmA%ROmYtX#PLZu}_!s`@RNL>}dm#Htw5hE1pP;~OF<Hi6VfC%<(=R{59g4NG1?0bf
zPcM~>Ft{`Nc^_qHRz3Ks+%wlUHmp^{Rx<HF@UO$<CTkb^)c?7PJ-N2lM`=fdIimFx
z*pcd%RkV&g{kyK6Ur1Lqo|9T{iO)qdK*%J1iAa%M*VvYrw*2gv$TA~g!^cW>%3;u7
zoUD1C>340MmAi*zW%v?&uD_l&0H%}^zyZq)W5oPJlVb+A&>vVc?8*Usg-uJ2x%NGu
zYo%i_-PWl}(t7d{z8xueK<i@e*78#LDYNd~P1VL+@e$zr%GA~{>^tL5PG_$xm`W1t
zHRL7g<H3p`BK(FB_6K8!Y-u?1>BE|8DKWx!+)6N%;eH=<X>bXEyf9dFII8tA$YAWy
zaaZBvZG6en@b!acS%Kan=hptqH^HsN0ps~@ud^Y7pMAB!btT^qbEkUyJf|8qXIKJ_
zS#1P9)GlZMqj<z6gQRZ6>RmtWEE#{S=ib^`KA98CnSdMlmha#CpkDCK>t$^wQw&Z{
z;e=qDc15QCtLTt*u_%7;pE~~DtRP04Z@R7S^uXE4oWr-NmK8BoO6)sc=qcFB&>1n~
z#jlU}u~ScnZM>i2GZy^%$2T-<rbe}^Z}<fMr`6sOem(k*Och4@?~dc=Gj6iKCTp6p
zraUn{T`AS!oOM%;e9`u?zPvI^b<!Z?zto>_QgFAICB@9!Ts2ft+0wQA{L$(rGV=H|
z_Z3h_evpO)y(WRcVNI%s4DMS|3$o54d)sW+k21iU-TH{nlIm1mzEV54HSLVgJu@|>
zY0H~EZ5CA5zBngvCDGj=9hca~mucD4hUWMbX_>Z19VYQOf9qh6<RDWaru?Jay?n+K
zxVgS|esk4n_>nR-<BG~y8U1`5BU_}-(XMfq$U?)4Bl!r}9510kfGL^@x~binjovj(
zs+8tVBNTquxamUe6%hE{2olozM#)Uc=$XRv(5w6oi9lCxfWrK@2Il_vt7jYdR@EKF
z0J4B1sqTMhuL(uB`s%qyfXtf!`qn+l0zuRi$|ls}-*3Go`~I%1yv(CG_)m|nz6v(Q
zrN#{K{M91tGryjk;?M*0gKEzuPOSO%B=s?_jKXRyAIbFU#|`e*fJ#^LZ41rm;aHy+
z@PFBNXERIv{@yz5%?qjI1_2YxE;dqbm6dT~*|qCGT%u)aQ{zg3siLXSoDu;RNL<l@
zQMWQHVen*&#{?pkgM*VS&+i%1=T2dvmT8WSz$&<E0+}}<b6*4E7^)M^0=B<~ie|x9
zug14~c&Cv=Sd%q+^!=F-b^Xa+@m@oWaXodOi%~`_$cxQ4jKzN=(f!6BDmCYhYaln*
z-mejFcmwtclgS+%7A8+#^NaCX6Z?%aD=I8PF=7os@&MU0c`9wRU#FiMwFJorX0+xw
zsY*3rB|femMhm*TA6&Gxt=Rx{zznO=z5}%@Ja01pu|gIS#;c~1l{3})<`H20!LW7k
zd3|0_US${L1`t-M1b=uLf|lz}m!T8N-QiVOEmd*W*CCFv_K-|y&HYSw`C^=>|KID#
zsu^dy#V$Ur=g|b<KX22Pq)h7Ng_&p_C|+Q#%g^;s(eayB2z-lDi!vJKt9BJTpL3Ex
z4sy@thH?|%4?TPL1I(;azi0c6Ql_lgNz0xzmF~$Ex}P`+o&}4U8y>ME@fkzvE4*jo
zw#78hQRGqf%2PERlwy37;jqFz5Z0U&$57)NOkX`M{;b_f4wR6gyF+_ZlF<@51RtFK
z{?A}~Y2furAi6r;60<x0Rf9tkleWkt_}K_epxp>GbWCj;AjrRH+V1vB3?f$h2mqPg
zz|ZQkE7hzk_!x1f&f>XJoJzgT`<RR&yM-@+$(DjYDlc>Plm{j!J`TA?#9rB#1kvC5
zt>~2M+KBrGntrAcB-ww%f<7FG%<j$ld`X5`yk82O2!g%bK_I16H_0Gx>on*=8$pC;
zis?rB-c_wR79=Ej@E}qRxGFlzJLnlR|B<eiNR#Yc)9uTCA+arJJ-55{j3oyv%I416
zfzylR0nVM+5xM0>2UuBL%vMc#UpLuWe3xhEi`c)W=ktnn?+&Z#Qt2bRpEn7jz9wcG
zF6Vmbmm~I4-p6>|TvhYx26W^IpIXsk9T*7c-8_{Xxi%iPrDToR>XJNw@mFc=^XqsI
zhnI5K`Q9uLo{j6&aTO;M?FoAGdKqc?adl792!4b0H>U;}FqZy&UOa#0lMQ%TOa@k@
zs1IS1+7Q1BNLZqFtl=v9vD}h_58GY|t8Cd3q98KbD1%d!kZ3vi>1GE_;?@GPbqAQb
z6yh<ZJ4jV3TTYgS%@!>9-zei|?ZZ_(^;v63P`zaNuBML3QJ(`BJ%!b1Fu`<xm!%p4
z2yBx)Qr}VSBI0Wn)W(Nq4$>UsJ!F6x?(?n8uC2-?hi<kDj=?{cOfB}?&;rhe#ebZe
z#Ct$HX?~-EmU<eB2h)j6zm1Zb9X>mk`&_EC1Ujp{nqV@F)}T`oEj>#-2CKlsvqv34
zz0W=<ZL57W=V6}Wu9Cd4!dd6Wk=-ehzNkGw&_u*Y77G6R)x&RjfN1SbcNFCOLU5M&
zZs`?L)yX(IxUsG}-2n?F{yyA@(M-&8B5m8L5Y&c<nE7jwJfO=<I7|pSQ+?hOJc-Ve
z(d6T#^KojWp#9?7YS0<nvL$s6dR6^ZVxA?ad>Bl%rOvd<?6P$LQdK39Oz1cJn7xL@
z?Dnh)J>x1_r*MvVze=qYP0<bXgSWfPZMEJibFzRVnUbxd^L%M4t!KH)vTguQrS|n>
zVFDAW9mRgy?PI_&Jgg>I;7X$xUq07}gd*t;cFSq@x8d1Y)z=R*n-e_@^#KAk2zJ!&
zfI<F-v%<RNKNo0#J<kLi#iyKcW?js1n0OdrL>Gq=B7N7NvkEWhQaN(PvGl8;4jFJh
z<+PuR`<6(uL*T%aFihf@!?1T47|=XDg}cgN$?Q5{oM(6q74w+mtHBBa6b^5gIkm8M
z89Al~qYG<Lp6!X5#3k?a(@#;0br}@%xz($4j<fhJ>eM}SMB5}y;S;@KjbZH!llYj8
z0S}p**}->>J~RF~d^ui;&<4#t=^bOw)`<A^9+{dAs{+M!>A#Cdu|oIB#BKq`w*-+G
zdwHC;TAR=<8{IhaiQb4MrwvJO*lyB`*aX@!n(mL8GlEt}+uw)kJ?+ghcVH;`@qxXQ
zWslR(BR<_##yLA;WhrLsldS&EC@t*#avx;#;(zq;tDN0!_|UB9H%dvfxhbFQHXp7L
zV@6B6anbZTlW%9IM#zrAJl1Y8u*q={uGZ%!k*;tCmv(7gB!e#}C1?a_RgkF)$R#ep
zQ6ljs>q=e1Ge~{As=*lm?=HHfhL+`bTlNx|jBC)=oi?j?{7wJwtQhKS_Xy~jVu4LA
z>_&3QxyZDzU_JNB@qIJt1rlh>^Z>FCU?nmd_mBsp2SfHCS`^zT;`#k76C+;7Tjt|5
zPdtEA4B<{S!6Zrs3j-;v8BL2K;p5=v&1|^j9>7hr{XM-F9<H(8N^q$-7|{In{X5OT
zSG#?!9+x)p$d%%G>D!od@OO)|44)cT66{H3ytr#?CH-`Pp7j)SzSHVCN}fr|;9Bj?
zB4!+Lk{zBhEDKV_*e$voI6q?_`%XRY9J=nHOE9i3Df!8P^tioybuUN1*H&U>bf0dh
z-i*2rixFl5W!XsdbWXzS`v;NpS$1yMYROV4s}7?7f|ji1Oc-<C=b!48Bq0&%Ex-%9
z){<UZg@~y;_+=sF7W*#`UpGtyxd^a92>{pXZh;Lgl7tn#sr8@?K_O$o6t~=nlsn6x
zMFubzpEzC`{xY#6<W}N_w+t#g=+4{&EnuxG_aNh728;csX1eq>ccpTvDbIn;69^c7
zSj96+Q?+7Z6!(K<mf!)ayJONDB)A|J)q+i;h_YV4vG;fuRv=mh<8sAscsGmNI>fE)
z<@kBteqZ>;lyT~%D9&5<>Eo#~_W6RSMru8d6bS8!i|cn|NY}zwUojaEfX2MNUCDhj
zO)C14(zY&~wunkjq!#UX)9CP2E8c_C1ElxbVgApR^Z95GY%cx@@@no^G$%&ZMOF*u
zXjL8izM>=DS<Tw&d^aH1eLBIpEa9i?`8j>8FoP4>9aH2r$!J=>;8KZ@7?3G^C!g`l
z!0xrTRTK(1fn775B*N(-t>mw^mc0CX0I^{RxBld?B?-V=egzh=Q`D9PzYEvY0+1}5
zH@S4^VQJwL;yGoz#d1&ykb7?-ZIxKpc5D0M8ySm>mtJ`r;?p+$5pg#i`jj=}m77KC
z`-A}?QAU)PRJu!5n1&+N83DgLT7dN2<7Z)VxxF#dvW&4LPD?H;X8&}49R`2fxz8YC
z$5j<^m3*D<_E||I%Fu54l*(WzSLkCZra=JO_G}cZv|;B9DP>K-cP=hxYBOc&a-_m*
z?q){Z7umnBpUd0sQ@}gT-cTr;vcIL)aH_icqB)KurqUyQSWrH|{Oz^{2bRbKV)V33
zZ?`%RdwZ$-Hbp(Jb2DjVvQat%D~R>BLC*W7p$7P+n<ytPx)6V!>$3amYhnVvXx!h1
zG0RjI1^QUCNzT2}{&-yktyBO6|D(nvN^CneJxqeRt7-FCGQ-FBJ6r?ntm0rEXZh07
znt!=P*or?UQ+zx8_^$S+&ReI`z2tR|rC%6lsShfbc`JRv=v3&oJ`ii${#o<bSWjPi
zV^8Irhvm`w?2>C#s_w1uZ%h@LN^FPJ9eZ>Mhvrq=eg;VLZ=1*aQqT&b%I}2GQYmDd
z#wi@xk}V1vUl{>h2^jg(JE&14aJ0ih-!^JUYVSa`C>Y1^C(+G=d@Wy{Lvu~Lv&Bx_
zGsyz98?c{qW{mlJN}g_yG#r7rbc3hHHWX(cL@rUK4gOCcakAn7Lg%;MTv3|u_WhfB
zX!iA@MU|;ZNB1z~dnxF0_4vQWra`0133<Vx8>2oyD<=K7yW#%+zYdHcZH#eRQ_?L{
zSih~}yBwY|!YIB;%>LIOeD-GNh`o|s+MaPiEb9RpGbV4_3dUDi=F%LUK-l|?;fk^M
zCvdAaNrRCCU12VhN~2@02`VA3IpgpT8?PPoQ*#pKTcv9?a{dlfv<TU(sM3b}jY;4*
zVQ5@ysduyUOyblRG4ehF{B-xFMjy~0mO{4^lWV2|g4kQ;hi5q#TdO$k<zB1^{&AD)
z@6UtrPGVobkiUBbtVl&xe2BUL_23bf-INVR{FM6ub>$==v`qY12UcNf>@%#D0dLIx
zxcYmv{$&a6wMTJ?Z-e`6>f8{5u(xd-Y3vi?KyY4*RWc%R4STmq0g3|cnn&wK{FBlz
zKwJr*^H=#KJdH+XfyTo-UhaM>U)6qWMo(V2@TAYd8Y_><<};R@JuCG1?_Rv2B_1EF
zkTQYWsu)j#e|hFbNxt<j5a~0)lc&E6`{T8G?nZ62_H`0_7(f6XUOxU`(NY^HhOAxx
zslXVg1{oPAA(Wkz!9ywd;=0j55|gV_)72ql@=No*jw5G9oFV&0I1foy?uT!NL0bYD
z9Kc@~Rxn-GeLpLRs}{#F3i4rF2uF->SIeGvCew|l*=(?>&?p!Djy-X(M<>Zbl4;I$
zZr=a1+;}6I?O~<5;ecPP^UoPNAs*XNzMZ*d{Hz$fEZ9t<&D)B&Rfn<Tu+M(Etp#Vw
z;+h&t&p?+fXv~B^&4>Rz<XwF3rGWx@aQa$Ss{=TST7QA;qKkK;1_Mq)yu7nIp{fZ~
zKAt2>#sQLOgy@x9*UlmE_sp5r`MCuX>49CEZe!N&yJpH{0C7m;rZ?p_o&#bwpU}r8
ze=jGc)9YlK3GAdx@|EAx<N4L+vSp=OZZUIO+TXh^?tgOFh|Stj;n&s(>5FM`g>FPx
zyL#oz>aEDLIg;Ml91VP@M4@>R9(3%xj%*SoZ+CL(x|3F66YCD15&_h-T+!zIYKA(h
zL)&yK^6y;ER2_I_ZC7#bWVcC3;TUf!63q6VPr8R-qC`Mw@qoH@WTlA-0>Qs;<Pyav
zkj4YbXIrXc$=E2PU~AtZPo^=X@i4R0r!0N|o6_~3w#y1iPnjQ3E9+iI2fRR6O$p5p
z{+<RGihQf&F~KxgSYrzI8R{*rHbgYVL#6rudB9zIj<!U}HNb8sVVNg9SRiXqX;;A9
zxQjjQK)Zbw=iL1g*QaP$`v_<nOAL1+4l+Y~<qi0UrZwKgnc9ubu_g!<Oa^Kt=tjX<
z9u&B9bqyW-^~8>h-~+Hgt5;3SDX!G>ADM<YejCZ~*!P0T%~v<9#3{yc;KC{5(~Cuk
zbo+c@{|oiN3N?(^sfIn6zB8TVI1)U(zmneMKLYyWv5f|pU0p^3NW}IL><kHsm=0F9
z#+0!4ETkCKTLiu*%v`ZA6X3M<Mo^JZ+WHSJj5?Xq;<x2zi=pl|25a>W1OCxx9Bu`>
zs=x?(dbCgjg~~sah2=+fmG`fJn{mX=oq>G0KjUSsk{t;wtt;QdBNjTJ<rE*boYcmM
zqz}_)z|z@^lCTX^`}SeSapN(kqs+eiL$9u!KAxM*gRXoBF_xXcmdQv{{`YZX)(M{e
z0x8>$)m7&x$<+yv!wlVb%`pdmGtaaUq@A(?;WN|Tq3&KSp`6eV;Kj(rMj?-0{%T;@
z_|ZNYPy|7jI~pDLg}0F`6ul<@+J&RRA^%5uq}2lVDhZ+<i^%!(CiUpI5odPc1q5b<
zNuX9Lm{<3o@XH=RNUi=Ofc3ej`3$Ba2MWgrBir_tOWksFxWMoz$Ul4io+4*}J=NE^
zl`}lh*p+}o75fFF(VcSM>BYky2-hY=q07c~QNPE{x%;y+ZtCIHTyP_Q%fpYeC9HFl
zxOI#t2NYFI28^ty!Opk>n~i<qvP8aPIIifEQwL^My~09-8wsXl|0%%dEOM6EEVIoZ
znqu#{g1uEFP;-_cS(aTk#9T0>7T00O5!+{O2urTYwUZdrQq_ssn<2xoA}@Xfz|EtG
z^7n0xER^%91@~AN|Km(o)mP{Aq^u%<tee+v#sm-OlbEAt1z&oL8y^3pN1bK!j~W_D
z$Q1xz$sya8*(+`%?iB_f=3J;W-0d>}Ste|nsrBU)ocU0ia?_8ndV=m-dkL=o<YKws
zCH&LD)wvExJ2iIQ92ALgHK#BBJQ4A4E$$2LU2|p%M-S0Nd97uQ02!Zu6xrcRS@^Zl
zp6;*4Ag7>)JsA*G`_?MwPGU;(JHk#&r1TcE6h<?6ni{8O-hJMe5pZI(w{DNc_#4GQ
z_SpwMxhwdpc)p#AnPH?(fJKnaK+!qG7O!8Lg17D{_4XW^?5KO5YeNP?UTV~O1f-aL
zjoZfBU2e-~g^<A*=i}uAAY$Huu?yKX;RlV!ImZRFUh<CK!JI+x3y3ABzrgmO%ke;j
z(-fkNs%~fZy(#Qn-=Y`u#&^P<+ut^ES`FrK#V?AL`sV}ISe6G619@X3^P&hDCSPUR
zTCcqr%g@y-g%YZ)O@23x48hA&3K4|03*@rxSlmrQB`U(W!Hs)!1V^cq(_(x=x%rds
zc2zIJ{JgM`ggSZAZAv#4+rnDU1AHj|zU><`_z|W4HMG=NFRQJa<iZ{P2&f!Xde-nC
z8>GjvJL6VTt~K({c#LEDdh=kFb{VNA(<+B~quGr$vdz}-Ut;L1#e7*v4pXjo3+7I7
z5d5yYNV3rPnfnE<uX1y23_^>|+^{iPrG>a^|Mab9HApjMG4zu~T1TY_W%@{CD&q<k
zw4-m~S;A>e;1MU`>Rk~0HN2acmH;sNtax63ig%T(ED|%zSVeecV;lBTnenDJt@jHr
zLPreif)VC6c^jn75PHG`tR`%ke*}O5YN)u>eP|iS1h8EB#LwUkh$$LG#%P=*4XjP)
zE0ozp#?z0=U<cVK-7VkwA`?21LxnWAOO8vVKiAEJ|1NSFP8#Jt^^z1_&i8{4oXyp>
zj1`&O%y;_M#qu1bSy%F<Rocj6vTUmFChq*XcuW^6N4{7CP2aTKu#-<#fp!poEUeXh
z$LBxKB!5&sk7s)>OhO?-L`r7E4~A!}znnWUI(PZ~4c83TjpNo)Q4h?U{pZpjm%q4e
zDm?*I`=#eJ&S%(qZIHdW*=ZgpkoXAD)6m19Wq5;+Gw|0?_=DgI@|^uuAnUVKxcXmS
z1Yt<i#dG#ve~7DETGB9G&3Jqdy!}D;PuIV}`X(b)UF^SG>7sCLZT_`+z5eG>`u^5-
z_i!!$gRDTte9)hs>Hw|5s`er2LR_)%dByZUV~KIK)m@$1v}8H<Io4=B-mLo~qh!+(
zftbcG9Xh+|<3&WV`yZ4hPK*g?C;qvnEcVY>Jv(iQ6l-O?ZQLzNbmI?nZeT4a0UTC{
zrl)}t{zHlL2fN0%84<nO72#Kh7{&6w(Qe;7tP+i0rsS}VF-xyMFR%%%K-4qZy)k^o
zfwVOjdRM3@=-e^Q!CIWPY)ZYEE!$$5`j?>GU%MTdFtcGfB@O)!@fH|S2tyZb+e5Q)
zoiuZIxWaB_ptQJnBdx*@8h>EE+8b{XwpY_Q9&-kazJI5|qD8MiU1*j&y?HI~)NC=Y
zmjW2#vmj6FY+-Ws9{vb@-f1_e-5}jGWnFQfz`>Y)47+#zz({|*_Xv0&Kr((tqId5!
z$@O|qBARy9fV2EHZbd)BGLiTT{ukcCHcoe|sLV?QgFQrs2MKa$vrLKdVlCc{$rq&D
zCLBO8eSXgLY3UKr-KHahGyYvtQKBP_Eft;VEsj|IR}wn?-@@H{Ull%)eNU@%v#H$s
zcp;{87gLM3XiH1T=g&UFP3x6(km`9S8HpRkZ+{Hx+#j^6$3i^#-%(sx{c%&K!F~Vy
z&!+0qAd@5T(A0KKxNmnbLu1KqsadT(lVP$|MyNrLqa~+m&Aym0O-tg6bpaq(MQc2a
z@;=OTC^kO7RKvsQwOwTL*_I||=6gt`kH_U?J!()^*$;qf(aO`S8CEj$IlJM0=(bEE
z+$#kspDPUHPH=b0jO;aFnRJN_qiCPbE<B*?<XhTV_+8@Y;)X+k6ttm@j?jQ}6=l<R
znReaqY`do|nyL$<k!)oK6{r_!>7gbIsXAfCZ=x<SuiEexXs%eOYrZ%ct^e|EoPE4D
zn3K}af`nSEN<8ix=mn*qA8@l2Wwk+G#X{Ti9>jQMhBnsV%HbULmL78|*KN1HVSzg~
z=>EqH3I<t8@qPW7dTkPu^GS88+qlmFGy4>H2&MyJJ4n19?2;Gi>cQxZbdGL8&YhoL
zgfF*N2go%GKR6*&6UY!cH6a?kS*JD~IN}D~PEMSDa0B}68hMAs&L^%7{<A2;b419~
z0rNZLiBu?W{U@+TriZ?k6|Tw|KdEBD9V&Z}zVsOSP&3{%tcy$PHtYK5KjIH~rlfEQ
z_t(2M$)lJxWsLOR!!mRz2chx{h{|LY-URHA#}*YzQjK-r2#`&(=b>>DZ$;`dyuVa9
zS?|z*caDJ2fdy)0>SnhE=rGXK^?n2<j5pwX<kH4x_=RGcdoph9k_Y7>)$o?AM4H*T
ze@G8nEa%v=hbKDk;%ZD>^El&Rvb9FZq&9zbF^C)_-y(1bjXF#JsyG(#AOtf{u{w*L
zH-Q@!M<AI0zWN)2P1>NmBdI}Kqtn%Kl#K^k|K+FM6E4>BH6y@>fQ`e~w@aUnJ}Tb_
zInV<Oo=~EIYgy1MAYT};g~YL)TWkxT8ci!P=t1v<<y_+MXFn6N2T@pQHr2|U+hDCI
zh9;|&%q%Qi<w)jVC;KJEzrh@c>hkMqQ~t4xS34^1W#?m&RKiqbg=w%I5<X{kpm{bP
zwA0@8RJ%`<@N3eGjGK!naVPX#<wZ(kmi2XoeXh%_FyYtBpQ!i}7N14PN=$}iUimau
zV1=pgqt~|hl^k=bPh*?PC&J4`tO|9ZKxlE~9>Q=(t@F<P!@dnaUOtZxucsbf%Tz#c
zg)~*%VfKVxU-~!y{e4ot%JjT$sqqh7)oGuNbxv__VFl+&Ya(EsYKxO4dh5>&V2`FT
z(eBT$9)9QvEmOdt4y}CDx~BPKrfQ3NqzgCPHH&c65GQyR17SEbSyp6)Tk)2?Swd3k
z<F2Vt+;Dx@rn#^OHg90eSN{LDh^Vh=K|ns>XKQ_Rag?0i4dH<=Q5pOCCTEz|L`bdc
z#@oR@;v2djMv?1=s=SBskAT`wvu8G}UQG-2eA@fZXgr8x(F|jFaw_)~fg`{$J6p>i
zuopd@Iehp;573R{-A(_5nVgkySXemm4`v;mdi|r!x?keZj~ydv!<qa<14S7TYPM~7
z#m4^$3)8Q4JYzMwm55WJv=ZP54-bHmqx=*r)^Iq0kPM-v3#l_2kgsjJh&JyOaH-wG
zb*ld@dsbP<vk?<%pyQrq_kp(-W_6c!L80T#@~7@|EoRkJ3LU<)@}(82Ddb`c*B2&D
z3(H=L>TA_obcT+V^_$_F#iJgxk?p-R<U$Z-{eF)-Fbu-hrOb{L`Wi(CvJMGh6th)&
z)iBULpxHFI3dQBCrW002OOmlOI8TxwTH?19zV-UG!7JryqNOwKe@bvJ2<n~Ia-2it
zeXL?7#dgo%<ibYE#^Q7jwMvH)tawf%+AN)2Nq1$qb11w&_@BS^uS@Bt+~5;R-}lN`
z=K5DwP8#*KG=O+$wr7Ab2)=UlNz@#}YpN1N=R4wX_dGwV1`Dg*YIPU=b1l4uM03;*
zCnFU`U0*b8O*3@dBHyi6{5J91Wcx6v|Gwe==y|O;MC@i~d8pDe$I^qv3eNaqkHm9$
zX$)>B8%~$qL($U<yKp{d>BGGc^U+_j3ow~bE${5(BV{PJ=HUT5*Ed`UGB32=YDlF2
z><x3vx~Y+9-=b8mc$qJ4J6bnc9UcgB2zn=-#Hp#mkpm~r{?GS|H~-yM^TONM`20=#
z%&#uzC=CQ?12Dhc;vhPeS+=}?V4KQ)CT}R~?%MMP;AiY6d1fY-6YcC+j}lH{J@$qF
zG=+}PUX94qxU32h<C;HJaUDqMgCxqb-I!k3Y&S%uv7GmGQ{7W&=;Ns{+dyhZX_|sw
zzqGoc)^8)1U+QFlmwME8agnf8M2!c}h&wz`dab~4`d(w%C-y7X=SKj)y^eQB(%yld
z{#{5hmOybNpOlgy*ec1vsQ@FAy-DcMD4N&6Ytxrt^1gOl^`aPg<yARBBP!dUI?pGp
zY`hFr7mvx>X7S+uj^gEgmpoleS~s{;vxqYN_=(g2_z3W>-#J%<YEd0!00qxUmcn&A
zgh|AL4Xpn;8)_%-jXDIFzpx0k`)1zlLZQ0FyR+B7F-0@Ov|EwQT8VV`^A5}8dg_GT
zwi+%TwD)Hd#Xr>>vq%b9cHnC7-ReRn`U)lJOzlXA9nwm-)O6;5zmf>!hwUMsU>_94
zGBvT}@>Oa=ZG$tlBWuNVCx-4?Jnj-kAC@-&)o^NRJ+ve7x0i*u68F7lgB^jxei%S(
zLQ5`RWf2FC^zopi{(PG+7^)aB_sq(k*Z0*3_+t`NZE-BA<>np(f=IV`zO!uic!J$K
zet~yve-2-}RGL+HHMy2U2(bEluz-I7ay20>*#E=XyklINQHTRhVuUkpl`^23*8N=Y
z#}i4a?)c2Zvs3QdR|~4sC$zoJON$Z<3qE`4;EfOF<$GI>o_7r_pHKW7p5L^TvmA1{
zJoq&x>b}wajn*yUrt@7qeOd#Gh-B?nNH$O~56@%xi>voYF4hPLV_YP-R)F}Qx(+aF
zHC;yHGt~s72J%(<+?qXZl2$@f?E^<*%laPhqEF_omUr?fme&Y>gmq`hE8Fj|lv}H2
zVrt|pj(}l2yHbNa(S(+DH6ybAj-o8<Qb<;QJR|^fFt?s$!ha?{-5JRT6Kfm6Z5c(H
zIXdfR8pFc#D4hb;X<x3@pSB7&ooTeQ8J9Fh-If0ck(kL}mRM3;WNc#=K%Lp;zML8*
z)eF_7t3*nsJL!6o7QR9g&ECZ%l*r3wWK9I<aGc~gv#>PedG50&ascL5vpJj0n92wT
zp)i<{t7udD83V0?A$u@RXVP)M?q5AQqb$8qjN;|%G6k*>w1U1!TU#_s5yhC}3>Y+d
zp5mEBR`$RZf!2daAgIlx!Z(=(j{nmLb(&ecbG6)LPsG|^J6S3z`16pTTsz_6LRgQr
z?=#idbP5_?b}iA+scfuWtn<B>%M1pd4kTJOxR$=tcfu<-OLOvCvd|H%xccl7upe`X
zm<K!bC#kb-^8Zq4Os!W<#XvcNw`DEEGQO_=8qLNbO|<&u%w6EJvlP}-LSo`VkFXgB
zrLSvX(}R<Z&m{yUbXn}ZL+a!Ae@!4;USS;HKeZ2aaB#z__5F+m#9K5VuM@Crk%CNR
z{0Il!#BPm=k@98y@TkL7T8VXBxkms}klNeU*bB+DB-^3chZjpCO-!y*At@k?HY|bv
z{7(zqm;G<dw>BGqZlkE|^^sx;_%mQ$bq@5$p|y>((Ys4ICXo1<`2HRArKcvdz`*g{
zfB$5Pw@pfK)h^QPCN>mz$!YHE?9(k9qhfAZ>jNfU`n}5(oiFdaf9JlHS|`JCHo#2k
zcEXr!#p36iWsr6)ykh4AL3echl9HScb4#Vr`?D`<P*)Y?$(He;HfNB+!B7j}nIXqf
zf;m^sn%BBL0@~wDf}8fY$>l|UTi3Xl%8uPxZd592?n7tTjk+c5Hp@uJH2apl#+u)&
zr?6lSB|S*~5o$?r$eE?@nxf-OZ}3`dRkv`KbdhLpv=W)(46uwh`Wg&63h1BpInB^8
z)vH;*D6k82<BZ${m^4;qM^K;WQ0o$hfZQt|0Uko1_&C)a0I>pvsG?rs&ilz$p?tF>
z8Ab%3=DC@GTc5w&j<3afh7w}S+-fwyv*V)*RD8^w&K#CU1@J3g9CbpH0naA3MJn<}
zP(Js-$}B4ymSsv39(j7VbRPqOFX{pS<@>TH2#wHXk+`S|(o=|Z#(OvW2ryB=aYVlr
z(=c21%+oT#>c7>2&3j4cS?CDV71A*<rvE&9f5ZO%=jE$8>aS((VVh>L+hvoiL6(0)
zTRlz-Al49)>G_MhI>TON%d<3xzzx*|+WP;R92d_v7SLkZY!mG9g;QL>UjlR7$WGsl
z3N53mggg<mAh?%&QAY3k01XQ*LBYR_N;&ZBi__f15hIioD@VS^{9jy|Mj}2|>PNtV
z^j|{??7TQ07JrLP&M&k|6DV*QHk}l!rsYn!QE0gN7c%&ZpwrEcBvOrS*C>Msxrk<)
zdi)u$;&%3i8Km@Hzj|g|QI)}Ql#bQUP{en#&f5I3(5r&-q3CuUTe8txd(?~2D9x@#
z!4-TCq6wa}=E@{;*iLgunp6Ez!OqFf$M)8#m&Yg@1?_KcnH}l)jXqgsa*gJlKg&a$
zHLdnzEVjvvQw+O_@xS7+zx!x9%Iwo(WG9~br1~Hh39FM~S>{z#H{&qTJdQiB!HPrV
zF-k=&Iy|-Fm3gjskNOd6hsDi%C^?y(C6yoKb=#T{Y0TO@`6Zog0hm~z{UZR{iL(-+
z<ehw;XPD`>hk|^u6fz06a?F|pUrY8q0{+azJpzUw0XL@OHmxPRgF3-*DJnLU|AVal
zhN$Z*LGI`1ype+eV4CNbCJuL7U%nj<Dqd+NSW!~)Tk!!@kUZl>^-@z2UHEbXAd^^9
ze7A9}kcZ(lQX%t{(H0JU&Y|)n>~)4ATs2Yyw`aAxJ#V{5&<*QHtGmrJI`@@}yPX5&
z6Vs;@SRVm>unfy%nv*N5P@8EG&cRP~(h@tuGUM0KmZ7Zm4~hgH&#*>1_H@l_wMh8>
zZ%=cfw|}jv)-1*Bw|u8v$G_W(CM37Hc0bz|`d|&4D=@px182K#7yRB%T!*~0n&OkG
z11l&B92@<<ut|e%Z@K2Yc-9%O%zrm2V`xV1sx3AFRq0+8<ldm7<Q+c=bPYLRP(9Bv
z5KCg^!IExDSZVdXt4HuMW_$p_d}cUy!d*gyKj{GviU9<>P1s%%v`XW3&uZR3^k((4
zUYg2UT||y<`Rt}v>^4y*TqLIwc7I|8An?Dmedm;M{qbzo2m5zPot{1x_#>+1y<yy8
z6%C@4LqVhd-bBMLd!h_SYSDK~$7LvhucYp0Sg@yISRLuNcC}8z<nv*yGQO?d^6oya
zu8(}AJzPT-9tTiJBo8Qv4T&aK{+OkTa>{NCOmgt|F$m1!pmpc1E=tjHWj7I%gCwLR
zR`q5dk58^<^tYOK@jVl%L(yzoZCdTPi!vg_^yOcda@zmf0GP`t9KMeIN4GDUM}!dj
z{=w&0riYPgbK3g}3PyVr|K>iQ@S4Bj^LM`X4|NKv-#wPvZE+OMDaTpqRc5#0Zq(Ud
zKUH(?lqgr?dxocI$qBL#B<dIo+WU;V>hTyqEOdAbTTs%DwY)v4pbXquaQ5cM9E}YF
zZrbH=zP+FUFR1&HDj(*U=GAm@3!`xAHsgd3d4LfeiJgQR>AbwB^_Z4cMx}aO!rB8Y
z*~QBVpWLrJ+)1U!r0WwShJU%LZOVNoQwnhJ&|0Jr;FqxE?#PQ@$cF|u3e>(!rCL2q
z$)Dp4vCn~Bn;h=y#ea7xF43}du!`4kyU(OEnD|fPXR>;gqn{R|@hG{bB`eHVS>u*l
zE(6IZwT7ZF|3+8K9l)*xa^vlB?t$QnDsK>l08@#dbSd`+r{&TWdwqXZgj!>S9aXru
z_K>m|o^59*SupQ0f$jXv1HUnyMk_s_>&lNvrsb05{tg*vmAUzsi-Af$LNeU)eCe-#
zF(@Uq{s&ackzT4RC}(rfmefzXVhO3*ACZgPPhoz}%wG@Fu6#*b8KD6z5N|tn7I2Gl
zQN?R1;moDFc%_q7vV=I=I0>%bOPfCQn>vS%y`jAYf70`gB#P#p*30)caHBaj-8Pxn
zef_>K-Oh|0|E#*7lE}NL52VlLl+|85H-W?Bk=6gp%)Gyxl2qSy{G^bT<cj~DItk;~
ztvFU>+tOP*N9CwIVfEiTqJe!_Iif04yRR2hjpf9BapWwo6%y3&4&Vj2ZgMbkK0yO;
zC8Lzakhx|40@@v$U33CLN@SVk^Pl+J5BIKNZiD#<YcU^`PVE=&+%qV3<E`oqOP9mS
z^{@Q()4vH~=&*6=7)_wgC}#I10A}>{<EtxQakx)lCe%H9e3#*7W`w_6j;?-*-&@oM
z>-dF<jf>Rup^5X_-x%=e26e4Rqq)%XK&<BetA^{4KMP~Cai6{~Y4ACi*?K$zLiq_K
zxz+ItIdK>lJBCes(L!at!~=Q;SPpv=hYcPnqIY8q1k*<n7@BPwYg++oh44kp#;4u%
zXxV@Pu;t6oDxp2!hld#l%Q7p(1Nphb7jer6l6F#!T$3HGdWVN;o1$7G_^8{R7cI-o
zmtMted#G}IyUK8IJjsmqrg*jI-XWga`RhK!cL9%p)2gKVvK>shR+R_&KcK_G;2vbW
z2UD-i2-C{OBVZxarn*rjOst__geU#yV&@x=@-DR)I2<AkS}d)TB9#+~%&whP3x(vl
zRj*f3&+}KLdh_n^9Z9nW=>Cqe8sB>R&O%EVXFJ9UPo`=^YfPTlM_Z)q26#z3A~D7g
z0%oP#|HYeWC`F$YS>GT}7=@Jq#@F!kV)}$D10;822>^YoZG8mzc$y6x2v`P8AXyCG
zrK2&^F>uSND)hvmaYpaV_g)S>Aq|`Ni^hXdnqQOm3#gm6V%>s{A8cmK7Z=XHsAu6H
z;Wa2UV!^CFZaH{6SJ_V8mQ~0w!saCxC;X?PO?e{x3x`K)F*#+J7R|NiSd*j(^<Izh
z(e4|!XN{?ne8E##dX=-RIf~-N=w+I7P+pa6v$h-@{3tL!N(<h7(GZ!Eqv<sGE_HCg
zFIu+M&nI1eZX=<I=4#f>_o)hzX{L`*Ynz_8(RFpp**Did<%nK32=KPY5zVnlyBqk?
zIEZ_u^HX#E)a)o`+35k}nCP3)3j*%6{4HiP#F>zlBgu+i2_K))iyu)Co4W#-$<?~Y
z$gSuT4mZ&LK^;mGA9yv-JA5lCBk`ZUb2m~QVY#VR2lQ1wYo4{D|Bmi55U8GC9H})l
zxtH#du`tBgU*P?C1e};fjJq(E=83)HxIw`7e{YM<O3woE<CR$P<rh=KMzAsE7vUme
zgRo3Y20wp(?CGDOR`~_ESCiy;f;d#wFN994zYp)5q-%bPK4YQU?bsM9lzi)VKcgJT
zY_5(+zwaop(?Q`WzjW+LlQV`<ix%0|$dmS2tKjTs^+2hs1k$Hw^-L~){jPoBiqJ`X
zB_j{Z+`^%?{{|Dxwd9(;guW(?Z~xa0o8`u5NA#3pA~G2xQ?N&Nlj4QL%64ZM|LAFP
zxIf=nYBP))qR_OW$9=FLNGLCSE<nsU7yFZ>6Snz#`nQT^kpbz0#h;?%#iAJpZfg0R
z02}v#n2*=Dt<7K|NfQ0})3XZFRMAQFd!kF4`2tzeip5V=n=&_<vMvAOEI)i#{9@Cn
z_ky>OH`|eLh9~N{=BxHs^nVyWmzrZ0-i>LfBMF<lD(jyc2n)+`R8FFgHQ&CG$!F0N
z&xAi;b0h~Fg$6s-bCfvJ8-Kh|4V7I~d1talZzscP9Hsxj<Z}EI=Mg~bvKIaZu|AH)
z7~Cq?v?8D39x8hmAr{-SHYXm<@4o}ZCR$d|$QkoP*}d{45ev~FcFK0zKL5h&V#z}8
z>k5x|JTaQZNbbXppX=iLqch?q!@WI=hfYl+yG!JkyI1Q=DrdZrXkOd_hl_i82?mij
zwYTv@{GcuJPVXN9i=j<-@NXwxv~RR-+M7>1D>UQEaSV{%!t=WMD>~USwdv|&@=nEO
zSo#U%EhNIysAssnKDR)8HjD(w-UPA$oAIVbiS^tlfr6?;eqqO+WU{915#S0R`Hi%s
z&k%aBeUN``)}3R#I43ksoQW6k`{Wmcmd(blSO?$8WNYX8b3Ujvc<&L=^rALvd;E!V
zBR2<dJ+Yq4^KOBI**`|>7Qam~lXmdgQ{&3hQ(k;w;|OaWm#*-v%-%*yWw`N8NJ!KM
zv<v;_c~U^HZ@a}6&oPQdn`iD2hH1rPh>;=b`6Pz`)2|w~?y%;26w8(<ozk+`7_&9}
z3;i@0Ju-+rJu^$<{v>>>^Wt#f5CF*VFs;rFmCU>UDdIhCu7GcdXaXOwAYBVhd$Ai}
z!%FO!ZA%C_-$cMsfNcG%f}Nk=Ken^s@c;s#F+Kgx8#2HOl|>Vtsj_UnmH{(j3Y4M#
z!ZFRq!%f9`B{q}antol*E*gDwY5$a$UP>VK{+eFRu#0e}tJAGs+C;d3$5Votv_wSr
zBTUdAuNWq&H78lqUDvel`HKVNslKRdXY|_6orruxc;DBm!m~ABx9d*Lg4q?n$7%iu
zt5g5O?JHAPWh1^UPlbd^5gQJWsVmjJaLVwFx?y<)5Z+WSyUwC@CQQzZU%1`X2mV;q
zcm%{e0)Dk7KfIW&^L!Xmnslo^Zm;=_>>05^{JSEUWZF#)u{T>||D}#c;lN5di#-no
z#$c9coej8E7MtY3b4BHIAT)NvRKLm{687zWrj<R+Q(%l=SG|O!Ea0-$v26iRo?uPx
z>#SWmsJM-_okQY*Lt1<1;h>+|^)r9}!VJ~-rnk&I1QUE{1qQK=9T->F{WOy$(WS*H
zp9A%GMEmgmvSa2q$&q2)P6FvfGADV=<$bV>a2|683+p+$`M)>V4map#J1uSu{Ey3i
ztUYWSihp-&GoXN^RT*#!r|CH)>05Mf%BbII9*#Og=mHT>a4y~i$lS-jP0ca#+}fqS
zdEXXyxBlsv^WOS^tyn7cuBr4r&k+BafTh_#Rq*z;mS++<2n(p#6`pVSnv;00L_;QA
zi*~a@;8%xso$OsBk=myF)J}Rs+B1$UYTIS6S}S$wVIL%^5L*pWfTsuZgguq<Fjdqc
zTAe}OJ9#Nn{Mx$i&2HzbRLAo%y{kFSO-=f3Y(Y!;2*U!Y3b|<7zgp<mizT~fG}pA1
zqzPnhwOjul0o(m@m3T1*r;UN*DJ>|<txv3!O6MSgD`8;w_a1cgYKr2UUz;rpp>+yM
z6p2ej$wXiroOc0nZ8Jr)o4jVx<38$UR?k_9*RUVv-VGwo*|6?wo2#Tm9|4KVl_&K2
z0$Fe2hWeG9?$vgqqCY_|TwMGp1W!|ckI^udbz08~AKrs41A>AC$82$O16?W^zGFT^
zJO`s>EtmB=$fv{M32E(#+tm7I#HKDigphT-FDdyje9hgeS}vxh?12h`Op%XS#l{jp
zn0eU7#g|RAqK5uH$Jko0=xUrv(d5WPASgW(!y$18-ISEgC|Ud^zEtKqJ;^ik@03~F
z8eH=<<y74#&>n$uYJnX*v$qQn%~ejAO^Idw+7#>NEX=7It7&uizyAEs_eN(X`!~&U
z72jd(o&vF96Ic6Y>+iCbVXi$m_-2)yr40dFK?cF^D7EJk<~g<|#StLddG_NA4Hy6R
z%@|g;_jA``DHZl9mFxB8>w%wad23N#po;8xKNV<%uSBndNv67I5y8=K-GNRQGuoBd
zw@2B^XneqOb=vwGwNYwFZFX*?^5%Z@IGbKI#F_6FT3I}AF}80@UX$2XC|Qsd%<NJb
z;DBf`Gs&YhOX9#ye80|kKM?>%tvfw;FQhvHfzD{tWh$AbE(C7_O<kQWD0hNjgdGK2
zp`gkYv*#}P@^<gKse~3g5{JJCL=vs7>qN1Ae91W=jwt#n!nd*hufB(RzWnC;S}zu4
zaCFhgkfNq@BCa>Ko5NxIU}|Mq<*sT><?wvV7(p1Je&Czb$ARLs=hNAhDA*)gZ1e0x
zS1m7vA@+EHT#Zw0KtuhIMuwOnF5>sM^>V2v0wpnKVRL6nFg9ycCqlp|*K*TmjKH2Z
z)6*Bn9Q$gGQ-_=)iVMfN_o0yHFDuqfonu-R3v+$e$CcVpMFXVGy@Mu_!6jn!tbHBY
zTwO8s-abIJz;CNwT~`VwAJ~)m#W5?H1<rTt4{R=#sVJF1EZ!+C70?SUgipnnX0JqK
z@($M=jYU`lFXf3JoIh#fBDl(3pJcXLK_0BO8XOAn*y*an_eAqHHGT6fc|`dM8T@)-
zCa)t%t6h7@MPyD)$&73AY1}H?YnKEYOJ-m>M=`_o3#!c%F#eX6sanPobw>&6DV|;c
z5T;=}3RmxJiucpFA6W830dT7lNd3krTL%F=oO9%D>s@ISR6y1}_9Wi0&CGT7xBMIs
z8YWnKpL^UF7bbjZ_Ov!o$5`Udr3pRwUiIrHW3$??;!@P}liYnnD~bzuk9~6(xhq7s
zgv80eS$Tprtq8F&{(VlY`0$N(xn!mfG$!M001J4)=zxfqQ9fDxnE$iEli*xG<-Sg3
znA~M1_4jsA`Z4Ve3}dq!*>K6+<5Ib%6%Zs=QTHSQH44qJ=$b!q=<CbmH5#4`_+5b3
zXg&kqSJK&aql1kOn@3|q-m<;QmR|1oaA~l5ZBxBu!@Jeoz{tz&{NKW}C8AcnZ&fsu
z;uf09wg&K{AR{cvODn7|d@2~h;EnWriiwVN|98{St%&V1*TDYj)S&!qfyz30`nD&Q
z=fdm9BLMyMqgnv|Nh|j==Y3KG_@!`K-3B^PblYOO1G2+R;_J5)Ty0PpD35S%)2*LI
z6#2HH3wud1T2fQbVfpytUo?Pa_F2Xt6B~X(_nT|w*A!V<MzW>*UA$bD%zTU<Q@@-I
zHMJ(|ievOj0x~#@3G0>u?sc5kQ&Q6tUHee#mh_^&{wYiv2Hneo8!Knv;LVYS6a~sn
zNXlAQJZH!+0oe%Sy1}Vz5$urNPI{^O=1a1Bw_%D|z)E=NU*j;UXZbmt)M$cdy*QY;
z<dr38oi}PiefkFq6o#1w?5+Fis`>7In$0__!cogsraTBXhE3#7B@!A^ZAFnSibx_p
zu*xWh@^bYtLfOw);PL`liL?^RoUVSU#s`Tq_Pjgf!7{aF7$5$+3EidrRFGQex60Px
zFPyw#l|M|N{M^&}pWp+Fe}P>9=JRQ%l=*<72$Lz#@;oz<FBs?{$IIEqE;1<E%O^kp
zIJMTd1OISb+t?zJ(iIy*5R)!q0B`*RU60hJ?vT5>QA{__jjioRDEU<L$P-fO40M0!
zN#CWxF~iz6m(OC)#^3AzxcFnEvF!(~m~FZbl)rcf?pQp_`GyJJ@!n2RDf6s0HiRUm
zyAJ!ezSqU8v&QAM;yB}~_>gj2XWRHfGKB1cSd|ZwT0VakDNM~4gVLO5%AZrK79U2L
zhQ_INEen3#IKZkTC0nM#u5!rvw{**6*V`!Erw$Kik-RJYa|C_8RI#$oxH<4^uS{Sy
zg6vpM0doXoPok)(s{w9A^6rl~;=HH-QQ$?}=!?E^K%`JH<ExsyRxh@zr8OEptTaGT
zHfE9vhzV0D6Xh6oR#A!?<R!a5gX7)(a=v<A9L=v#o-BR%wmrpfSu2%Pu1*ywG=N(h
zqw^{isjgC7a*W3RZV*7p75i<CYs=9mk%>O2<}%s;XIAYCs?(eVdkx|`!b+aAwhs;e
z8W$dvs-=3-USz)j7ra&fMN2m3tbNJ?LE}XfD0DK(;Jc523YLaI<N}EjG*fW+F9G-z
zXFi(O7k_8DBPFE<T2-py@CxC(bFIfpZ2AmOqMXr}RG>ZG0M3K$qq{@uoQZ(pWx8T|
zuaA-cW#+4q|E)bYm5MF3v!FxYPrHQ+6;Y|_W&P!?&fe~oe3qq?Rd-Id(z^H&bm_sb
zNG6OB7&&{R&Y(Kd6BnxlzLx)`E>A){&GbKB0*szr5HOF>1T%P3uNMiHnVRY~Z_*dO
zmPBq>PJhsSpzvw7s#+YM!I#+&dZFfQ0Us)K&F`MaCKMe$dt2_(-S608x%sJ~K{S(p
zmMyeNHcba5`~tU0+5~({OR5MK<0UFK4*XB99bwh>V$4am*S^G88bu_3vnRjwn~HtM
z+nLXlrxe8hQL{i0Sb~zJ!}8r;5^Xu8qpj^Ybtgsps;pu-B|W_(K+?i6#gt%*DQDX2
zOA{B`&FqjG>y0r#jO5qpXk)HQQx_l5X8}%k{Fla=8kaU<)vnn;f>ggApJOrdxqjW)
z((u8YOr<k(p!h!k_CN{0R>oJ^Oru1g`4u9*cr_8ouFg3W)-4ZpImo8x#XTGz4K`KD
z;-FX4Dm_}?{(!sx0QC?50EK)}>Jk^!7kkHY8v8%iOjkg=B>w=Q*Tz1pR$XS}elX5(
zYpLnJOj@u@C5;)GhUGN3kY^1a$T$8emc#sI6p}~P7_&^a;Y?sJgXX&^z*nqsMHv#3
zA3O?z?p_oskwxE+;&Hh7H66?-(Z?blyQPp&>mpRH@^Z$#m(h~NAE*9jj8~07RoHL9
z$5rUQgS`FCi&`@Q&MV7*lVN!@`<H{e=(9^L7jjG?b1Y5>%@L&BNp*G}Qa}{Ti#VfI
zkDS%Eg<}%7`8ux&HyFatT%?;UP2Ide2?#$~u2E+s!cqXBHF#mUmkE_s@+ta#nlS{(
z#8xK-S7p(pg6|ABYGF}@JQGA|dL6VWlwv>Loc7TBL1I5DF48j;S&~i#ROZxa4{5th
zhVJScDH0v|Ex;5mzoeZ~*;Qo6n(O;GuCHU4B<(eGZ5UMmo`ous$5M}B<&+R<DPv#|
zl1@9N(yZAeG6y3yq12;|tvDk;Ra<DJE;^|5N@<6bxgxujk+8=EQrbx*<f%CnPNizI
zTjhVAJEv&Y{>&h^E#`yUw)~Mx;tcl93vNN*)f2Y}3pNfs(p=s|E<LXzsx`azg>o~W
zp+QB-&|;hHwM&0|l1ST7%K%Oka4DKS^UG)aa7gDh6neZbdTrku!Rn%f`CmiHAY1J*
z^&g328iU;zX<;p_LO7)-ADTYlizXFz=7+XP;&NEzerUXs+g<>ren+*W?xWmn(3dg`
zW>~<+Pc%%Lo2=f^jFNgaIEvh<mT(F0np=KAt#Zgc+i?ke007A}EuH1H>pG#}af&Ua
zvYAX#Z9jD#j+GQr8Djx+;8RCxPWuaBmRej^_f2ycIX`vUvb4cf&PHm=R`!YA(56JT
z_Xlt}pz_JPVT^o<XAa9{0C9@0odvbmy@GOT)?29U9b;^5H2cJcL=UtP-7=MO%I&5>
zGMS)OK1EX9%3+WwC%&rkLS7(aAOTeu6Wc(==S;R~vGNF}m}ECm8(?I>AW&BlwaMEU
z!u`>f2HNE}vW>r*l5~Ys`#^uS6;UJaqPhqjelfqwo-L<LwZm@us8{z9&SU_AQ=5q;
zV2|dS<=9`~j9eqgBHB3muG9)ffTHt6G<LS>zauBfs6meDw#Ldu6xE2;^i<1iZU}C8
zshDO17BR*s*&+S15)X7X;QRsdHFo>xi<U>EA8ulYkPlThvKd)qL4oF<ZD#Plzb68S
zm?g{&wSmPZ`<;!Fmque-SGt8%6M<EhmZ@%Yow=<MhXI3iRF{ec#xuoqF-q3dP}<xv
zlXGs)YDn_uVB&+hl%#{(HO+A0a~@08n;S%K-yyQVLJ&_B0F0wDs2usC^yiXJE(y&|
zGNQ3zj8IZ>bjc)|qz$3K(Ms83e9^a4Z@5^%q|(z4&clP%CFt8PxTBoX$?nO>)wNI_
zxeK{a4;57Qw+7-Sjqrf-D)Q}vL<@IATZUk9S7XTI5gcqel2wIvb&7@($mGk>rp<Wv
z@cfQx_WuC)aPG(%s;Sk!hf0Y|(L{x!8E?f$r{6r%FrG38jMUJJdo(`jTz#5Fn$BbX
zCS20eY48;2`SNvAN!fuwOt?7}aL}@z!OaPI4mt5(VU$mmrUMIMvs({E`kLcNy8y9h
zTY^5TB2)q~#S(|(@v5bbPA)8X$-&w_h|@1()NK~x-NOPhapH|b$9&g_`YY8F=+}!J
zu382-BRyBLX!o#c7VB|r;na?C;<y@}EU?S)b}(mIBhO(#wtqBTyD{XNhhWGepMrxR
z)>A-q3|!+p)s4A7#Egokf<Q2OHDhfs+k$9x2grKmdCwGGzxh`U&*rOEQV0i;L<t@u
z3LlLWz!4-{4GiHk!Oa+wiBROwj{pz28XyCBNPWpyT0QGV1ah7Y2qMAA{{V_cha+<2
z5m7QVX0A3@P(jG40nJe9ca0edA>+kf#zQD0sv<rK0L>}Fjs-LlI2F=3;}rmNHU>pf
z`kP<1(X3v3i4-s#E_<kbUFthc4#DS|MfWlBT=Hw@A6WXYP}j8?B$b(B&J}awv}yG6
z&njIBlO%DgWS+kDjrPBPATkjEKNSYD6MVoeQ!GutIqtgQO1M=azpC_DaK{vCCo3jN
zP1`!=*K|nAx#FsB5XQu?z^zuFZt~j`o<|s}tzyDeW4vQEbfdvqD3Ijj92)hH(T~)N
zpHJS$VW>)8(Z~ZQs`6Ki#K)R?F(eU?YbIPvBx#nyZVu7+#+`o#qiYr2tbyZkkU^^?
zBZFTm{)&F4O`=`LrRs8*wR43e^<PhExAyne>2Yf!ylyfGHNwq_;*~R}k0P4199V|P
z>ZAx5WOGm}VCNYWp^CQQ{C=vNETPga4h=ywYzJ}Tif~<b1CffP*RNLI-LiSbES&`_
zGv2G!J(Xle$*e(hb15>hBBb>Wq6<kgx5OHUOe-a@oFV499-)z_e`iZc1-L%h6K(|%
zw%Z2(0QfYPG5ei)qo%cS9!7bt3R3Lpy68(SX66<VyBCackE+qxT`ci#PLKX8BLGOQ
zHn`4e^Ffw1x&6667wWp+pR1Mali<Uu)1<dW7WiYuIOS<(Mv3;fUJW&Q<+`rn&AU1^
z%LZ<~s#Q;MvN-%x2+kWEeNhmp&T3g25mc{z)Tj7y{{S^3C@EPVUV6IA)7CDb!%jyE
z4^&cebb#q{cdtENXX(8%M`u=?uf=obzEAbmy{P(!RFdZES0IzMbHEj=^$w+Z>I=y(
zCU$J}4??pSdSk4ZW#rdiNv4ElP27x{rI*`Ns*CbwA+~33Xxn>X8*V2Abyv1}TB{Pn
z0)o`wG04CXis@{lm})%->dUP%MS|g(t=ReTUdg6Tx`b&wO_<nciutuClv?{|8*|6q
zZof=@WiFX=ws()Z1~|#_T+L>Z?r`krX>~R5k?#=49C2iKOBUjHW`Tn4E11$~WDbqb
z6=fO?frkRPkMeaanj%YJaZ?3s<QimH$ZXLIgGv%efGhc@s{r4cjvzx~jfNy{SaVE;
z7Ce!>@C7_RTO*ot?FqBU@lj#3fIFuCgb4^ZZt2K@$;rhw+i)0aBZ1KFh#3l?1cGUI
zo>WuhUOMK6cf)>YP;6No?c3)y%Nf8V=8;b41d5pT&lLhSuonPVFL<Q{5x}OgJFqAa
za0fK+04T0=g#aE6VZT!ScV+2aJ=Q5!OSWH#2dZS7bb#7Q**EHEueARFNonrB>dAJ?
z@j!Yt@^`E~O@HbgQcKIZS+^5`o~j>MYxmmjsV&{)tmT-H3F@eUB==p7E|=T+OS6}#
z)Vc8<i;W9by3=ptxwny((X+v?ufIcoQ!TwiV;zO`fL$QK$?m=|gNEj`o|x3HG<)dp
ztt4b+An<D3`hRg+?5_@OkDiavkP8joJXb4V<GS--(cjb?Z&K-zTir|+=>`ZVy7Z#o
zE(U9jI5@gzMlwwj40l{PriLKkig52DfWug0isCWVIOEMGamFeTf>j;)s7^e0M9R75
zp^-SvR?z8)7!moUWl0pHjtxb|e>EzQM?KVw3q>{MnSqW!i8TmNoOhbg$cZd_7*#dg
z4HTF^$Hhk<D3O<jM1v!Wj(7Ous_9s$;Ly{TDVjmYdE?D1M!3yK7C`2e$ti$wOaY~K
zo)11L@u4IJ9M?n$A0y37$KZDNQ4z6^8O|yz%eX8pq`A3}Byo)7({&5jENoup>OmSP
z$t3q)4f>VqnYF2&(#lens&H}ss?&o{EYhS?mnz1sl|QQ=sW*DIsx7qEDFiLU4>jpO
zq2H-K{4r^|q`y7@B-e$_r*4nj5#$=Kvbwv|Z`N2#BO%DHwEa3N6uU4jTitJ?@7QHY
zqYi`>BZ}tYyl3=R^%*rQX!QH}F)EA#O?xD6vH(HIHO8D=UfFhTi%nV`nvyoi=emuQ
zsn3eweEFs5Zpt6jHQVW{#s?n*Um9z^+_%#iTjU&oE9_6yd9mqh&Bq@DUmR;Jsedas
zIb(|J`fA~`2CKj&x%P=rJO2Px5j)7hDiXu`r->kYFuMqEx+hO~pvo~*xNuE%?8H~d
zvO^GQ7vO2vamLobz;ZnPE3R_)L_2Ow=Z>mJ3+=E>0DMx&h^w{$z6)|IdHQz|I*R`Q
z?W|KkvB{Nj&2IkyP2`Pkf-`bOalLB)07)i}m!|&!)>dt`utdN{H)FbWrTB^sjBrH@
zbtS|%auB=YG%d%ua6>8;$93~vo0T)%!6i)4**Ln0s2%yKTF&MO%SPONRC*LrCAfWr
zfli-Lm`uu1h#g|F$vdc*#k&f#X%;=s4(b{2?q2iSXxrQSqirRY<}j-fU$awg_T~{7
z!TjQ>Z6@sumo^cntZs66{_4tO3~`c3z!U}IX2h6A*>S~I=`&qStrgx$&NKL`wr*Ep
zUuA1+rL}goUCuLsMNf5e1;P!P4OWq9HZe$MR372yIH*=2*F?V{bym4!U$qavcVW`Z
z4Ui;Ykx*LRDn<|-lTqBP(jRRH#-O)_zjm=76rS3vV#UXy*Ouj{_t(cX`+G=kj_E)@
z-C0ix?Aok4pzY#x+;hfyrQYj;Cu5p8VjE)^6<PlPO@!(K@;LJ2vqr7jJ<qa6KI+T}
zql9h61vy2G<Fx}l$q|BM>Z;#Yk?uXe+mNHpS<H(lATSgp&X9nDFyEX}i;t8<t@KL;
z-KH}l;k<EB-K>|HRLaNqQ(MDo>>f;JrJLraI0qeZLel7uhF96>;TZc*jCsu*)Be>$
z$l3hU?I3uNhGUu!RJZr=a&o+im%03zH(R0&c3Ildj4P7Eii6WI$rKs7bCdU0R?1lw
zWL~Okh|negAMH-^B^{{|H_@Kd4AW}@Bn6=!YU*smWwkzBbwXQ2-@M6QKI+ln{{Ryc
z$JH6hN|7b;q*Cd#+_a@6O{+_&S|q0~Dr-e?a>0iJrM)@tiZ@cYi#b~cjU!8O8k|$D
zPwm5GZqMB}N|re;SsaWCKH?={cH@eYZs?sNj{8z&xc0rQ=BAF~1wpucs%b5wk1{v}
z*Fhbu$0r<9+$nHN;H|h>E}sV>DoZ;P7s?Vq^F`k@P^J?H=n96x?nG=z+NZ45o4Dhk
zTcRyO@7s@I8;GDZ*(JKU4x?&=MBKzgg`1qy;fvZ#p#wDQY+_B^54gM+4%UK9IO3mc
zY;5h1&vtvDVz%3UCc(+<)y=|Y3=gVVIPj3J;<+lWPyMuxc)+ZKT$a2b)}C<AtrNEu
zNh}e;DQtPIx^|;>RXFlO6<M>2l~Op*#8c;zFr#P!qKD-9J}Tzj1~kbfkz<c`IjZNl
znm|r41zAiZlYz|+VdsItqX!k(uEKP)EzDq{z!XjBz*RldbTruH4ym{Mjqv9SRLSni
z!DVqwuGSgji~-3$E42BB78W2m@l$Fx<%pBI3eM9Pp8K(_Fxx0{RVLHmwVv7*Px26G
zIU$u)8)hJR#ZM##PD79?RF~L~ZZayBCcKu{91)vDxP%LtF~>BpX)wplyK(oLb3*qR
z!(bXZ2wEtB4b=%`l2n)#9t30Fen+pWceifP6(pAim8D2nup6^ca86YAb6;a;%7CY}
z$s~78_8vIF#ThD-CNurf7V#P5G58cBtTs`wJF}Y9`V-Yx8Xe-Kj#}N02+vhTeP-~#
zBNW{~Pr1IjTYFfU<a2-ks&eB}O)|($#o9iN)32@dD@D4ta6=5>8YVZ~apYDz(O#d`
z{X1f&_i;xV+I&{J*@TI`Ys}|@gxW`M4EM&_F5|nZo;Txz%|y6fTBI1p>{UgNg2LKB
z>ND7)Vs`BHRY^BFL5eaN%K)eSsuGI`Tnv###8H=;u85U8PnswpMFbqt0Xae>;-tqt
zQzCG~zG=i1Y?H+@-~jgucYIC=qx79YlMzaI`=QR(Y~q^8gCrap3xYmP7rwa2=Ci)B
z^*yeIVDrf1em*Oj68lz~%FaTI?l2q*@Sk4lx|X4I?Q-q6Kf^s%jXs^{m*A%^MTuJi
z^@pkT4^V0iJG=X8eku<YOlM;eGAYm9I?i0HDyZA!)DkqCi0yOLdOTR;jyqzGMoGE5
zXF<ABTX6t&O+|Kc+<>Q(Qbx*+{{XiY(oOC;jYbFET2@}@*jTqA%AU!m-o@{$Zs+QR
z(qutx?SsyFt0@^4JSRL=yfhSIbsJV!Vi$mD5;k$>y$42y!s__jUXY6?0gsBT^|z&D
z(r5P|KJ+chu&!*iF^)}=;ORe4lftsW-{0WM#cy!`0OgHa<IY8UC+JV=RN8&|X*#5&
z+mp3fk5!TMZM0HY%(8$E)4>&s)l1pxl89KL4Uk1+mQ|i|#@9xix)-Lw4C(fL`)P3n
z%qu;-f#YG2L84OtXBidqFX%_=e75pOqiYhkw%jANeI;u;O$y5khDI3#S2r#<2TYKX
zlCXmN0VAr!dg9|Cg{`Eg{AcR0KC>S(d{%sqg4ixh2C)&I*_S?Q+e>s^B_IpP6b;c|
zZG|7{Xx3m+&sE6v3v`jw(j`r@^FdE;Rd-FvN9tj{^6Cnq911T@wh-H~Vf}GKT?wT>
z<>5zFm)qNqX`^=O*-0cyF9MUxebF+))>ko0yNr%SOR3rbs^j@%ietp`SY}rFFG7mI
z;|=L@i{zA}X5!SvduEJqPB=6asL;qm59+IZ9eh~~ME?L9)7(O{$DDKGySTD@kWx4q
zA+l`%LACm)k&NP+v6zkz2C{y<^=-b9Y}WSjqg^n-P<p0vq!?p!me`Vd-_`coC8Nb0
zf$oUFP<pSQwXH_~09Mr+d(zCTdOj-BdG4=n<hi<Ll16UNidm8th$he<?xrnNu*%Wf
zhooZ31st!EsH#H|*}=tEz>?k0#kkv6*BeoGF#iC06&?WlLEHJQT0K<LY6|4dKBei{
z@<Kl3w&RFAcFiQBC2neqUbC7R$}*qswRZAbtm%Q1o_{s!7k-h_b>Bv<)wCd7D)M~S
zcP@Ww5qS>@JTS?YOAlTTp7gyc`u^!)wuzXZ#}(;*n*Alcmu1EC>=_3Fw*LU9+8&y=
zrYNIPbrHj7y7YTnV6lZ^gIxUj*<C=t7LhJwWo~r%bZZN1Yg8<N0LG8Abx^#9QaY^-
z<+L(D%IY{B*OlJ-q75U}AN1RY0yjJp;<-~&o3+`#Ek#r4-e70r)lV4D8K7+>TZCC7
zU{s8ZQ3<>n&*ZqUfk7B2nk@#=RgjVxb4SL-lqoz@rXwULC-X`-t7f?uZ~p-9qzA3X
zj}+)uaQ7Gz2lq}!aKkj4+&9Eh<d@IY5EG5XzFkvptr?U!7_Nd)4>V%Qxp3dcrvT)u
zMJvO1QW8MJ9MN}n;I8DL7bS|H6e@z9jt%0KiiQ}Z%CE=GV?R(mV`-vWJTXWb<cwf=
zri2{bL=uvUwm0=B*4DnAuy~=7Ug?Gu1J!)d>TOQ%Sh{<QnHk-Vc{E?BwMq3&N=fb|
zW-NHgs+Ur7xzE*i^qM%~R{J?RjZ4VsbZ73MliVW$qlyfi8oar+%8jQj^-)7>mLqRI
zYhJ@Gfm%Vi@%2}Bu^@{LQ2PrI0Y`plm_PLJ-*i$TbLp*S>q69Gy0w{?Yh-|XudM$7
zOFeUE>U}ae+C>*CpfD%8`07ZNh+$UVnDs6H0H(EAuC1hHP{VKsu~@ZQWszF!(}OnG
zPowUV02!_aX{>+gkF9JyRiwutm3{EPCC{4K1miWtlv;FjRFe=7x?FKcI2_kzl?)*q
z{wg<LuBvS2qilmwkq}8A86DFGNB2Y##zjQ`0D)DsI%f`PvqZBYQ{5oXVx&>W=89x!
z&0R$Hw*_U+)6uBc<iwN5iqT$M$8#B09QZY#o))*5qh}r}NmoNf{fZO}{nC&L9AcWJ
zgZVVFmM??H=9LXX6<yc|ii-B`+R6r=;!u&O&nLQzQ@^&;?V4%i2#Px<ymQu`r<Yl}
zXd#fTx}GuSwdr)y&pKTc=E||hlDG9^)z_M>*|M~emed~yx*OBW>3dxq{{H}T+_38&
zYM)tHx1?$^%rTk<;a)9>IU>C_Ei`dQY<M`?GCYpiHmfqJZ(tD^{vxST#_LdbXn@L$
zoYjTgvXG_Y+B{RV=<Z{8cuxd#S62mAQ|UT|-jjT@MI$4|+~C*LU!(rNgIm+$wYrcA
z)MF&~UpDJ{c#TqA49Ur>A4gu?X}2-UZsj(d*Ed(ASrx9$cr&;<eIIHohFW7BRtNOc
z){yHK%WZKW6R5{0y5E8r3gAgNx_zA_(^ia^>Ve0lFAskT`43tVJ;5YkgI`?!s<DgG
zw`Um}E9AXtQOigZ2Q}FA#qnkxUtm$o?}2Z$D)?%6i`&4Hl{`?ep%NnG;F`FaAp(If
zIUHA1!UHnI@+d-A0-=#lSvVBdd`QmYjNnwyBKu2($e|<@08&qP8O>e#YWw!ujC_&E
z9943tR^E8cPoz43)go10#IUSdxT#{2X00=8B4@Il@>wjy_^{18PunrT0|UB|=86p}
z+6TZcv@=G~Cit8m>b_4pa%lJ1({V<YIg%@1YBB*d9GQwmETDr_Ha8a+H#;1a!L1q?
z(FeQ89!+GPH;=PQXr3$NKotlF>WNE;f*E8ZKXqKN+fO&Rj0gMF*Vd~wvqcMFk=|;Z
zs>0F=Tj=Ls@vtNDMA_S;f<eJGO`>R%TSv^rxvODtwrmnY26z;?61}nHWWJd-#HnP2
z$TteDTew=}Fe7VMYtMCYY*yYq+4EJFRuV&No0cW$W5>m|TXCvpzRh7|-mDl^e5F?P
znLyn`XfeqWF!u=r@G3jmUOUX~{{VVMp6Wn`HO+-xOCmt>^Th{ebv48e$T_2}$+)*6
zhX=(+XA;9HLBg7rlBR%_T^ZYZO-=Q0dQ6D(&MMno{lT<Vv}WJtuXcQL6kyaZ2fe^r
zcb?jH&|7b?EfzO6iY_1Jj%s<Nv5oNV0sPdhY_P^j=v58&nA(KmP3AQR{%K;A<!#a@
z471pm0EkHEtW>s<J*;FiXYy!!ODQeTEK=?wiD)K~aOVPpR_epTKzDkD)45Az&OFns
z?wmMVl;)+9RkOem<Q~mV%?m^B6~`H<+NwyLS47gu5RWU4YM$p%jw^*t;F5aHLv5%n
z)$2g2Rac6Q^kq7l-4-sYbBc9|C-Y&8QDxkh5yxrn7{KGaQ1IV=<~}MdRz{Z9U;}9C
zpJQq5+Te0Pp%ohBu4~I16M=QK^n0j%MZ5OoLD};|%$EY-up|uCgprA@fb8O$wn;KN
zq|CpkE$$<`c_((pc&jZ&@_4S%VFan}r!o6SXyT+6%^=T;zIhXt=7D>;5s~gA8<+(>
z(+#kV2#u?!4FV7jD!Re$-r=3H5FRNYty<_V*O1FtNR+(5u>90lnvTgmm0vz6tBb-{
z+X?bMaY4gop^Hdz$L^k$+<=|-PZ^2R<Uv1G9l=$`D}{q0GVbI1pl;`Ha7KgACX8a6
z;18Bt!#ok&Gcsj>%|&CVCG2dfFjww?wvm=xOnw-vD=T|(8_O4(Sw%!GCb=u`q1z_v
zq}0Oao+|q8M3!G|4<owE>xntJ!sh_i%{8~lMnsoHGlIc(^NM;qD(wr+bRt5a5y0+<
znUq72xHYO$@I()18^<ws<QgLGMA$+QDj4K)r;4e+o<wqTc&3aT<VMmodKwianTIs(
zL;(A|=Bso;CD2z%PaZ1HUzDL3ayzPL9k~MC@&|J^Qxy%m?NVFKL#<2}O_83vr)g7*
zr6Ianxkad0si(k`OE8oqK$Y@n`2CiP<bGe8<tm42uYZb?OJrpanyOPwvYJ4b7slTU
z0&i+{z1`!u_mn89ltXNH5Dgg;L2#kL13oA@MJ|a?v*)>R69=5vTY{r;G|6{6fRx~U
zv9Y-|_C|c9o;l-K*kEonUY5wJ%n!<{z})A7MrfAzSJ&%nX&XDa#sKPu<sMjS!$rKh
zrQ+LL#$HA^01EeS(tp#deHz&>@1qZL!ypmWOZs2v3vC_+zPyY*%M9{5uSi3*V;HVB
zvs=0Cfxl0u{!#(ewD@l=nlgi~E6?w&=hAOB;FyW8PHw8VSJPs>w`FA+#|F7pbQcCK
z+9@Meh~%E@j&@LYwzKIsC0G*~H86j1L#fC#tg#YCHk{^&jlnqvg^U*Y9;#T^>%{=F
z-qt}N!yahAbfE*qQpG4n;-`xJWS82(%}WIqp}t#}#S;^U8(x5bm0b5kuOA?Jq9{Q4
zlg0q3?hf_H7^RMNBL}*9Lyy6z60&H0z(zBk>&^cFP`xcAk;!#zq@LIc^^a&`hML`H
z4I3aJj8&L&%M7<fS;1sf&zNnk?iy2R0+8h3iiYWBfy^=tGMpUOs(RbffAssqs@Q_N
zc_Br4hN8C<+`Yr&lgK^Sqtogmnl_F$Y%d(CgW$+Q`Ke=8i7;?;-`#X6kbDtP+%(Fh
zf-6mwQNrQT$XuwaEk5a{nIdP#c+F5G*kiopVxW7O5?#o|0ZAs@YAm}GjAoqGqknbj
z+r~wn+F>B?<JhZ9S#AxGw!QxVCee%@O?l>@>a9Z2@Ut;bs?zBGqlWTOvak$$t_Hsz
zqDgM$FDJD0eA*q&LDl$Xf;b_8cg6yi@l^L7nzXvT7fyRT)yg1z9ONFTn=5?ZMH`W@
zk(%SjETJwL>2qMgJasi`2l`|5_TN!uy+tvsU&N0ly+6^q{MuE*=~{szG4V!fJ3xjQ
zbm&$90__>a3+inxFJj#g+bZ%1tuG^_c+E?WOtNWF=+R3Ykpc*1VZjxS^~_4K6OJmI
z(Y~mf!eOQAxd0q1nz{9if_oDp5LAv03BQe*lv<TD%`Vu0-&JSmyM;@Y<2>_J*PGNi
zAmW$Pmjx&IoE+C9TQ$R84xXAkG|yMmZ@`Itl~6IwRDSfkZIJS66LMbNLH<~vHnYqd
zb~&J;^SeyfhYGGsYlvl-sYc*aE(j6qV}p)py8)CKAkyl#injjdM(PrjqmEG`nonyp
z+J2(iee*B}X{}wit0Pqbqb9KWt78lYR2}`~rpya}<|`g8R#-(wERRVHv*g`tex_ON
zB#s0rGbsv9c-+2@)Gqb6)U_+-lorSVx~nz3)eGi8a4Vy@)LKRiNK@5pj;A{QNV)n>
zIP-t|7XAw>c$NfFyY7IyhS?+dj!i|X-bZAt_bu}An#1e9rIu!B;Bvp3(WTMm)Vhyf
zWg4w!Ei7uw4^Yhn0}CK0>or8T4<mu%sU*6VS^ogY<;km^Iv1JHj}`2+8Yt=G%eHxc
zQT1H9%8Th2np6r~+-`AR)B0PgM?IrhHZliQ<Tk~jgC;)fOXxjHTU~M|94n9wXxCx)
zFtm&sY3!Yw?ORSdcCGu1P0^M)Y;<c=p<bKYa9@XB>6*==-)X{BKRjnOL8irb3zmt<
zVc7exGMhV9eHx8Ma}-UGPZjdt>fWFv^-Gw^Rz~i<yVahx{{W*zR{93UF_0_BZS+_5
zx2jtCAu-zT$s~7Lbc<}a%c6}(G1|K|Kcn8Qxt27tzYVjcb6(91Xz_+p7#?$2*gYv>
z29%ceajHCHh8>euzL(Twv~Sqn<YR?nS#!8bZN(SjQc+2={Kd5A7^xy`cT=6NG6*BZ
z4<e9rj;fSc5+q%irBla0?Lm9Qb}DEk$@z6g!9i%-Ta#SPgPMVe2O#E<JCn^DB?T)F
z<Oel1yr*}|suDbtlSFP9$m0~qRvMBICyEyGBmCnZ-6g5X`5G&D109Nj^m*6n2dm-H
zty&9q-E>Ajs__j<>TODSE^eeO=O>!>pVco$e*Ifhvs}ssS!>8z%x`GjcDnFEuJ5M9
z7TaB%?PTWNK8%z$>owc7#40KO0GjD-VrMNDKp%B)du0~pQg;6URRcl<dsTiTvt3Fs
zFgR>UPj?t6fuA&j)uWWFFUZx^)bPE8aqZYta7UT|dxlhyoc(5q3Y)k}O|%XvyLK=c
z1ou}Lwt%O)Pc>Wna_nTzF-Xuz)?)4SMKbm>Bj1`s7x{N701E4k;dvP!RIDY(>DR08
zy)&#wJTkD4aNIM+eUs=9R#|$VNRDVFQzp^4X1*4-R+3+BWBE5gSGoR-X}+P*qFqFn
zSPwf7)pB*%pqBptChaVw{wLGL2ufxM=77*Ocy&8Pkyvj7<iDD+JmiYy_H9<X8_!~t
z;~duxJFcJ-GBMRPfE?7MQwYa&7*iS-=yOrY-{z$`9aJyFW|fSE2P5-C-&-v4_44p)
zUV9YabN$pzlxO6R+HI^k`>M@vQn%A=-sa*!6-SfZY4tl_eg-N&U=lwy^PlP-v#U+5
z&1H8R#{wJ$@M}h&Pw!1d36m<v8)JQ4>I=_M&dUsiEtK#9?x{tyM;ekwXuCK>Q7nTP
zBly&fx<X2?$IW`JJ{aPT*rSh=B(ghZdr;nH+*dg2t7TSlT)E)&S31&|7zH`aQ@T7)
zmgjKDtGtx5SlK2i8RH&Jb?Zit{{U+t>jY+_wt?A<uD}7%u1Qr10w7y8D1=Pz>OJkm
zEm>IG`;ZycO5%oq8@4co2uD2C{+}rpVitrAoss5+CKLstYS-Fcs+TsUfJ2tWeI@#L
z>ib=PPK<k?PNNJnUpZV_$X(1zLa^tGH_-R@dM>K16r^*=&2qKcFL7><X5Bu0ygrYh
zKUUxW0NpE~Jgt1WH_QZh^1Hb;?|!=VCBCERhyMT~`^7mKuK~Jd5e5yFC!A9HY+lBh
zHBXYeP*ArU6BzJmCz;(<2qcd*x3VnP5v)BZ?xnU6uyt}l#}(3}8Cf&o#AoCQqc74p
zqJ-}Fk<AG*{{Y<kYmVsKq)8)GBb5{wQD5&yT&T_}=hGG?@6u9!0OqszQTs1enr5RU
zQH4Xa)(vE3EKNk!rfM@yp32a}e`gXi@`H?1BDPrHX>vgOG&kwf8=F$n@^R*^FD=;I
zF^psbUn|tb;ms^<p7TvFa~fzXO|eqqKsci{2%vaOA+Xh5Ykn=p*K83*M<f?<u?Oe&
zD;7m9$(m!r<P%QPWR7yibFltu=)$oeF}6(sZZ6{oE0rBlmY(ws?1vxKRhCX%vdE@c
zSqIn)HB)Q0cQa~nO&k0H<X1kYDqR>vYyj-louug@8-`Ejs#~$W!zDp*1u&`}4l2J?
zh^Ya3t64;C9`S`BR$6^xKi|Exw&opTtHz}#!0?UoUFqt`gCd=OX(Ok&tCK<7>Y_c0
z=z08A(Y#Y^Mlq4yJGi@Lbt?wbV*dai%u}us1(Y)!VurE2P{m6Eb3*EgE8i>bB037B
z`3}~kcDJYtXiKD^0phzr)a1K|DyRFWT<K8W#4>UZbVZelSi|kYMM{R+@;>EM197gz
zH80r8r*$0c(#N$^XgyU-+E_Z!zGd9qRohNc04N3p9Eu9IfpiOL70fJ2ITb0qB2A2^
zCWjiFjWIzBZTrPb`-^gNN6MAKuF!3_Y%$i^qstM;d7)ZMc^ITltbV9Vs3pB`Z5YQN
z*r@HagA4xvieg*uH565H`3BWtNvAKn?gR>d0*GV?IW(T^wyB9*Ka)aU-zV+bMFivO
zrOEIOw)-bo7UhcP6jU1^VFUefRQfH<lIB($MtH7!rkhg;bH_%a#_gxzvV8Da-`lB#
z?c+5ZDk8Q3_erQ+dr*9h4Gqw^h{lIJcSSbQQilajwSNqA1>Ob@D&I_%TF5_O4(fvQ
zOpbZ;E^-cP)-uuA7!Yk-V>PB~4l0=&rAS7S-tF5CI5;AsmSlqnm^3bxWR}ypW-qwp
z(RT*bADUN5)I-ORg==FD;s)$cGr=^+DU|^CPZ4{p3`Am`b97*j+c?ccntTeKbVlMq
z2~z$jTRT8<@-WYeD^Hd;$)6)VQ8%juX}Jidw;l-FT@`n+?Hgkmqx7Iw(+Bx|P!_W+
zw>a%bbbbBQaViUR$@4{~_#~ec1vE)-GfqLts-063!tSG*zPx3U+_4xq>Zor|w*f7{
ztr%UhmuVF?vbrJPPDwr0BxAaPOG?LS_?qJjs3J0RTiQU6VH?41iGtsX8cR@EnFsvR
zT0qduWoIP$6l9kWzYIodTZ{OP(Kn~jB6GB03hT)jUXl-V+dHUXliLTAQeC3^p~X{w
zJ7jV4R9wV@V$G6G8KtB!HgSbD4a+M`69bweNbv{@%VMsRZZrx(uOuzPVxwk|VON~h
zY!>$`H@sNwAL*l$P>(xy9m1-XI{mzj7kmYNz&h@f=kZLI0U8C2kyZE7>NCi{x5~yl
zs|`9skdx$`P?Th&ZG|;wfW@^yJ<`eqjxaG!Xz&g^QT~|HFSV^fZ7rc^+;CV91$~B6
zNcmDg`c9R3s$V6gk~EIz1cB9k8Tw=TeQD|YM7g<)Np!;`k=0m!oB9sR({@QLv8&xM
z$znRKwg;Z8i>uaddtz_Fr~XnHg98JBT*P!Moc{pDFjp~~(jU!s2?mi3NWIje6<WTT
z74!@pM(+l&H`bRLRo2-7F%w>-%g%FEn&z7hp=`)hZpQ|oQ==IM!k*%gL8li4a4Nd$
zD~%%T!zN5b_eP)+N4_(WKz<n9u#<2+)b`|W-_r^l4b7f-sRM;M#VE|Uwz(L=8L3uA
z5BREhrs(xYL2?NE(H4sh!*=2R^i90NLKi$$a!G~xd8wl$5Xe8efGk-Guq6Cx&9MBJ
zu~ESwaq>KURG$><kZ92g>*yABWsyM)FhQ>;_1~k#w9k8Pq{Mk;9xK_L2ImwF&8&AZ
zyi%Yj+z>@shcvLubVbRIIU`K@e(jPsXrsyJx)yLY0lNg(qyD6NE=@jWzp#rj9#{d@
zdDM^=Ic_o7uSbJCb4Jm|%ZcN3!3DnKj_MoBauAGjR(4Raxda|6ZB{*p7#TIAZv`mJ
zdt@9DPq&WYXJ243a(KlUwzA7`vBsr~8~`iZe@TB$5GrbVvS-RE6_-9(<BiDCh7y#%
zCTr5rYH`{`_wlkR9z|->$|+P!6XAgBy&GNh^|jTW*rHV0IKZzwx`J&sc1#_h*NoQV
zl;q`)kHPG;exZ^PQJXJ4IqG?A99rCxRB_F2EOlEOn8b@R^W!z;Odz}f^x~2zFQbzY
z%E5eK)?8Yr6-?KYNrzMNi>7V;U;7J)_r&V5j)<z*HL3pqWVVydxGw^z7S{SgM3SC*
z=8THPBihopBf76Xrcz(JzoKLG{5byre5|mRF>!3$Msr!~a&7M!bBr3cxzz2gquK7N
z@%LHNI?r(IhdJu7;*6c&M3&gPM$1Ii(o2Pb+deBzEs%8&7n;C&V$wr=vOhraUY%>S
zL_ezEjm8V&$J98%rvbWrMl{2J%_g%biqMmjQ@&0WDQ;j7YRFe}5k>r;CN(7GY{gy6
z4a6){p+{(*mzz<5OB~o*qq~AzOZg*kLX*{P{{T*}c9U$)`4qZbc-CFAS7pASrH(tX
zvNZH0!2G2j@kiQv9t9xGz}DeDN)9WXaf<4!7}K>AiuD;<{l}F4q<)-QYMM*_&}_It
zl_Sl3zv?X}?@Ygz*6A4?4mlmy-Ir;RUSayB`hREY8*_6CDqNt?1G?#HH6GL2`Y>uS
zJe>JHRkew|&BabDN2Ovi32tjmb?K;d?J`*BjEUnXvE60u<c-^C;gt1V%|3W!=;vj{
zD0XO|pWR)O;41Y;Y1c~)z?w0Qrm3N5_bLKOK5FYrvXV)7A0IWNB;y!1`VtXxl1TTD
zM%)Yi5+^79JkXk)5?fxDh<r(^e?)3x&K0+R<NpBRT4|?CyOdbhaPn)&Pxo+lVZ!9h
z>$+vOs{xAgFyQ_vbX_LbOtx4pV+g;2R+^^B^%aa`2eDILL+!MCJdDxY_R%R_j<iBJ
z6#Yv{OPD>##v~l%Q5FaajQ3X1pbL)`Q!KMHqu)GIe$wdeVZbJ?+vG3~b3l5FOa00j
zVED?sf+%lK>R^xBU2!t-Gv=0q`7C9NY5Nq3kWY#?+6~=9BwzTcK(UdM8=gf>a77FV
z2NdwccT=E}?kWZjD}<Tg9%-2@MRwnv5EI9^9D_tbA>D>NP{>K>(y-b=%`l~eyBZ=G
zZU>B4mVTmoFc)o3#V|W{73r4p2Ot`mqKZ^#oCa3zuECmErMe|qF{!F&%37tgt2reO
z)ja+xwrN{`w!8z~dvEHGr6#trmgh}{S~um!IThm4+qpR-487N;)8~$8+Bo@fI67oQ
z0Sa~~d41Gn@}%%6mSx7o87I1bva=_$9}GO2&{IR@iH)cr<YTI?yNX1QdX5cQMoXcK
zcPqwfDbdmbW&S=YOQ52UU@<obbvn@`xhoo>W1Im+!lG$CxYV-~fr|B?(+@ze!v6g@
zJcS~$YBdqV8)f*hJdThj>2K-bd6QGrV&HPBMSFZU(8mCVGywp{0I1=CAc<p$0H9z2
zMMQRik<EF$`K6Xt&dw}r8l+SyxX~}g%mkQ;`7Lj>eMSvJ*=3B3k;wY2+rpC}R{-X!
z;F{+_zY?ZRyB<f?RT)szjh=|ZCnKt8IH)w+=yeNanidBm#S+6D)!me#7?LTZW}V`i
zc*OvSbBt6+>ZWdLJYe%m(8!N&In5^rkx~)Q;*$Y+0)+;|1UFsQC-p1Q&}-H&aRh3&
zNHPc=*4%ytE(R*hSspnig`8BCGv%4=uI%m_(pcNxUNC9D<hO~VehYZ7Z2d*_n%}_p
z)<_oNMotHH;}?x0J4JOFSrFrqUY|*-S)=(m8L>QU&T6|>ar=kjtE2{E(#F|UI2CWN
z+rj{LZOni1RPYFu90nq`GJ~$5Z)F)}<n}5k_uD4<IX)@CyP!?LbHSx`WK7E8)bWZS
zB(-Jz%F8Lj5#qFZJn1c~LyVsX?z4gxF)Wc`fE`t~h6<4*9zKOct%VoqDlA1^0*qp+
zCAI?Z+=+=bWjn0SsJv4pWPoI^BhTFykU(_?xG*#x>l7oAnx(k55ZaQbAoeRmbBRy5
z20q19>RA1&Y#io>)Vd38_E1M^Gwwoh_f5$RRz%~$r^P&_wh%HtywXi`y_FqD$LgwJ
zB3pRLGP80zr%oH%Spn<C4<N*)vUZ;obTO-1v3B5iq-ZFokTkFIAMaCJLREnc=7+qU
zOrkir0QW^jBwJNWaw{%dt_!i%p0(%}k#yGsym3~rT;0S9%>g|B04mD<p6U)|TYkZ<
z{;azqP`JtNzF+G2o;_5zF3)%A`Bbo^iYwb^xNz#Eek$8XwP>QqQ~9B-=FFQ&tDAXC
zMY1&i0C8N*vwL=%Ro@`7>IE(gY`Lq;Ib@a$B!Bp-UytrE$OC>wTU*@wQQ&{#vSdoQ
zF2BH&7(}8sgaUgwqC^oa1jd}>ij09Pi5OFVda=l31QYdC^2Yv=U!>m4adkbdz#|6$
zebkGhSuN{bZTX)RY!>0?_mx0nMO>hUJiZ6!o>_LkhXJk3sFed<gbFr_wR>YNuF!Fc
zu2xUn2L`UK-B~~!(zf3$5|fMIqBdd~)TznOG<49Gj8vC##U0v~CnVI9N|8d+5x^B2
zvQAQT!K@r36n=#eX1111sMsQ^MevbXqfC#*R$E+M&8ZcRCRNX7io+>cV*Hx(5^T!g
z{%Qxe5}%V`Rc^OE&Ays_f=qyTq5Um=d3y<4jIQ4EMPZYM`z!v7Ii?o>0OM2ye^o42
z_Oiwt;4$WsacsOZjQ(m8@VXU>P=Bhgn&3P#OM&q*!^!+m_IC5cNs);rh_ryf42ARk
z)n==yP9)g?+}?3UF>TTrbx12yf#!#9{%R`-$L-n~6aCFDnQ&Qga1QUy9N`%<Dfc)k
zVl~YIi(wpJ;}{eso~3TwIOOzbsqRE%Av{ql`*`5}$NH%hn=Go2Ah)*dG7!L#Kxu>9
zxoFieD*E1Nt|BE!{-{X(m7RtLYQ;VpDp$}Q_*EHE%|ir>GVCXsZn1C>ltG%V(xjG2
z%O8jzb#!3%+5}hGd~MPwem$D1zq4sidqquus5BDC5~+R198q@*Bftn4;*}{vq{-y1
zTUmkyx09~v8WN5ke~}eDCRj4W=A&%hNsQomr&4}H+a-x%kqd!<Dz@fCl17aflU7X%
zLl(t6P|#TfkjksU`=c6Mv2UIMt!>N-Pv3Rk`B{~A<YtSxAPiJO+D3JCT!H4Bca}6&
zkJTg}wO3JsJE|R2o2yWuVzig2vRiFYk~^vi<75n^W9qKcw7Dps(M1$5ZSfD9CN|on
zw=^ZtkX(>Y6$(z<%IB)+xVdsf8MU7*I1~idt|i>8Xo#*E=MaVf8YW2nvClOVaAbUr
z(k)U)1&7E{w~VPLwgzx29TCsC#EvP~WkmV%YKdH@$o(oQE>dQl<Uz>lth80Qk}~oy
zG|Pjrjt6vRnK4MoBLc3;CgIUtb7D#yOV$UPl*0hS05?-j<PPOS4c}Ca5q1YWR(^k?
z)U4*1tbr6{dE$tgSR+74{{Y2L5VwvmkO2Lfj#Z9z{{R?LDL4(DE$Qz}>YCoJmM}!v
zByMbQE9sBZ??hPoXHJX=)vgH3F&yTubWcoa`V5Em@Gj>609Gp9vG-p{)N0;EwI4gh
zr%`su<QVRUbCXj(a%vavK5GwVv?1!d99JHA&2c#x6$o(PQ_y*+uty}*mo9KRsDeD?
zo;t4E;0kaU;8VaLQJ@tX#*YR346dVj92)b>$gZ?YqYQwUN$$N}j^1-w-&5K_e`?C$
z1_OgZv7=^G6l4z@WD(+%cgF;CSflE@O&47{T=IuTY-c@I%^4?!C4s}E41y?14J7<A
z<0SYVbBdZ4U`BhUXDR_a(t<+_o~Q(|hET&}o@mHlV8(I{Qwe#<JkbzN#NeDzA#jWU
z$fDqNV}n)ENDzW(q$Q5^;)tPdw4OSoWd(6b6pMqpo-t4;68_pNt7eK=)qxlwit%66
zFGoF$vR&DxVeEi9uX2zAIPpMU+C_I0!72t;7{RM>XO<amMR{>YBx#>6$1_7Z`~by1
z>7~57SmKX!HvkIQ{-k;u_RCNc>G8A2BYzR%wqK>+r>km-sOo4MQ_89FUAL}>x47nh
zmP&g;{{TyWPg2+>rK-jm&nl#KUcYY$5voQ4s2l-F99U4HKvB@A7b)>t;pWdQuG!PY
ziDOiUIl$Rj?@?%LcN0j8H)6CQK^Z2MKqm*PqKlKG#x*S__R?ZvMhEJW*6UDDi@@0*
ziuN0=J_$}<Fn`*IO)AtjeWm{ZimN7{7Ej!Zp{bldY38vup*RI0Kk-%C{93q#u-u@1
zSFZ~zbRP)R0r;v<QQE}Tu0jv$mKsbj<wR*}vdhWy{q!2F^Ze$14QYKn9I-^JDa%p!
z@FLut0o^tg+b9^O)l<bu6AOFovt6J|{zL~Dt;};r><_$nuQbwSDIf&a_e6D;-wbj^
zdHik1B^_BSjg!rKVrALMCa1I1$&{;hIH)JK{{SFugo+YKSX=@;8tSOU$90UO2`Up_
zwppb!GK`+69RlFlYUp!-PAcnEi2mDq9~G6jo;a>i%Z!6u$hku`h||dpr?~0u?%S(_
z!4*5GE8SCiO6X6eM8N0cR}a=}(x+(PHBNzMQbsDe=|IkE)=`m~&THC?Hf|P9%_Qd-
zD{Lw*Tq7Op{{T-zdut@npb}${JlBP4dMUTNVu`i4e1&}_cRJ4o^f?4qn0o5Y7^X8v
zfX9+5>{`EJ?y+U3_kJc{PSb6k6;>Nt{{VGpG%Y!xl#SltHBAKRb7JtuF(Ub`FX^mP
znM`+wanA(R{`}_$^5KKoj2h#V8)<NK`@FhtU#if<>KLPh`w`%uH9n!F+ce;n1e$aj
zED8YtVAgS&QZ6UCxcAO`t7N&BLc99|0;HD3B5pCZoRK2@h@k7i6}DMv=b}$_WL%Ii
zc&cb0II9b0C3&PAo!guPnxofrc6R;cx5h>1ioHYw<Y~-!D~>5z3S~E^HD$Ozx41iH
zUODqulCQatqO&^gmeI-k%RH-&NEK!2onAY*{h7WqF9aVn7ttTu3oxn-c4<ALd#ec}
zQZhTJB@C;aVw!<qzyR3IFT~`IO)w!3xv5Kl30eUhtP_exW1RO;nFAgwL_FY{iII~>
zkfg7gBH5U5c?ZoykOp&#P{SEh#Ww;4&k|fh&`JX%3=nI?KU4h=HkUk?_DWja&PX0B
z+G3LflTW?2g8I#^r$FfA9M+9KqF7~Ut2QMyO!*F2cDdNtK4}yrM<w#r=pU)xi<3gV
zd&nbZwR4_4SDjsm%7grIUY8bV<%Z;OvSV;`!mOlC?Cr)pQybsEk)nx78Nd_;oYKp7
zu)?Lw9C2R7`fupayKgSXC!M5KI-OK;M%iW@GRWxz{+ap*Y9^tmN7>4$73;RqMQ;+u
ziU0!u3hQ{5ID#$!UVy2UK;({V&F9T5vfR$bEK3@sE=U`N5pLNzH5@}D<x=h1!*5kd
zYbFE(o~jGvj^ZO506`Tax~kA`Al>&yfL3XGg~zA09g-5(u7Bda9?I@3%XO9(46HL)
zEke~VVJPeUR2l}SaiLx<waF&kjsZR>##>zrINv9vur$rw^G$+uxP@eigDVaQrC>p;
zN|D6U9!KVo_gp)r7~%A5vIi9B+EYL3sK+CkjZqV^-3$tEoYRNqxQtK=7*}|~86Q>V
zU#gysTbP?rv4{s8xB|U9I5`yAQDjoA0SAH&U4t~R%XCD^jZITNLiGcC68lCozoVZO
zK#@6+sq@bj?w_q5hd#sVT5LJ;>IYTf@GQ311UNghj%(CuwGqu5M<Xsb2TUGCKJZm7
zg{cDj;{f4@iY>Do<m?%0WDx|o{{SGt&U5!#3Q268;DOPUkM{1gS}m+gq>Gnj$vh16
zR1K&gy2Oy~RTu)S^fmp$JBBKwkeR50i$8CECFpfgT?T9ef&~~C2nqf;p=1idhCAx4
z=p;$HX*Pcq$8-(cN~Mq-s63NJ5b+!wf_kCuQKYwjbK}PbqajCf5oTi&gNm%4DPudz
zACaRHIbGT@@y8*l(M=@4ti&G+#Zbrxa_Q}^;06bZNTpYWfjkdCboo{U43a6`O}1E2
z<NYR;q7>IE7G1<)b5DpXFe-Sdbv!EVRnI-p@Qtj5xBFErc%F^=Z0t1%)TysUp7u7r
zFwLBS#%s<008e!Y()u{aAA??%dt$c|i;#K6e9!!gjbF)8?mZo+g>qMFmr+}|WgqcY
znl0!t1_wWi0Ko*(9m|p^-8#@Kd<M~6Dec+MXIj@qyfH^SzUz=GR)R9)WBf;TS*k}N
zh(~QM8_p?~c9+PYJo~d*wl=QEi!HA*kpUZ=pQ@>~(r;tAGyA3Y9N^W>g@l7GESrr-
z`<WuVG3_n&RjIgKQDjx}g6(8zcKf3Sp!E&QHIqDQSOH0>tnFsbs&@`WN29c}*<y9`
zj2cMC`7pMZD9&h;UEc35r4>&VrO+B>k+(TuI?YKXoG`-P(gn!R71}V)R~*&3GDd&3
zQWj0MY=c~!w8H>`4H0c1y0U1<>|&(VtX-4bUTd`2HpP%IO;u4!!seW571lPQ)^eH3
z6U|&l96;tcz(07dcq89}Kxz|IyZx=Z6>z(IG$kh4BDVxd54*Wa=7)yWZG&vUCZW<b
zbhv{m;f;0Xr)ZK0q>wC)(9J}p)do;$&?Wp*ToV+1p3OSLOK2B9?oZZe*jh0j<y@2I
zg+I9c#_^E9RLX5FsCCQiE!O3tDn<nksU5g1$Qh4h(GRJlND^U;(kvglUvoH09MHXX
zEDHn1T<~hWZ=;s%+Qj4)?ySAEjdm|pS2mb`dbbfNQ|6l<$9sU^AU7~v9ZYX??Fu(k
zn60wM4oRyK1Y~9Z0G22l#K{L30Ml<xt~v}}=S-7KR*K(o?1~94ov(-^0Gw6rlnB<q
zgW{_1VOXwr9w@@3-HE=L9-(i%hEd|6wu6Fkim^kzI2jnK`6US}5P15gi*-U<x*I%r
zU_i?XC9dU2aLNxAHK>MY_mj;s?i{JdB9%KE@B)`&SvETD1I<2ppoI%YMro159D$S^
zH8C`zjCaYqJc_&E2T6fOZ!Ru9)3`^T1zdjT+k`8wC}Ar>D#wh0PSj*Fs+CM)q`q7v
z7XH9*?m++tLHNFqB67xzTegbaMZj_>OM89NZ(;KLsITM8Zf5x}Rc_euguCD-%GTyI
zc_fs!PH{osumOqjRvL7VExFv?3aYwa^0;$Ni<vNGUuJGuz1xP*12pEhiBl?aPiCjQ
zwpiS-<21yK1m&|`Ey|S@t_UE8G>|avmgemHp4l9I)X0dkWtyY7jyWF+Ki-OIzC-;M
zHbs4~(Vy;;d^Eh%^r+G}7#_z}6wFwXqmfG|89o4;Pmo*5kr)F+Tc2`2f#Rztwvyq<
zClr34Zz86}Y-75UQBm)ZtGXTRKwE+SPrBeQR$Zigd>WoRW{HcI$*6_ol1gF;k}9<(
z{{SP`(K(CVQ5=$Bnwl$iv>zA9sNu9`m)w!@j)g<5Ey;@zNrOqmp4$t!@O$i~Buo)N
zNTxT#41-3<r*>EVDOnap!wUCJS>W!9))^HGFPb)ZS|;cCnjOY^>Z_sCuyeu2E0_Q(
zSpWbUj|I=-r37K*{we4}^-HrO0=YpQ4AcnqIi|}X9%-z^FXn-~xLA>y*bEAdks?dW
zl|&_&3|El;ta|w@ZKSc&pLFanSRSe0slK)_M%Fe@^KJ_R)p*7F&2=M7G=+)hCbwxc
zPcO=S8T0B^HMTvJH<uR|H!X8JGf2ldHNO2c^~9QVi>K-?S_U`-o~s#gYC`c<@+-wB
zIR?6UH1ToT(a(liMq7`nA(r0e-7YQMGO)-X(uX^+d9NJ(GWDC<O1gFYnS}7HPgU&D
z7-fNFiG!mIh84okf#Q`juZJ?otsJ9seN)$WgVjV18wA%$xEu<gxU#mK5*4|{9R#cn
z2l1*)c><lMzq+uun<r_;C=sH}kjHQ|O{}1<)7@7iY&;x;L}!3fiU4$j9Iu*BZzFa&
zsO_c<Hn#?d=y#eV2bKusAW0gwI>@P@Bp+{}I;j%`^GM6M9B{&=6Ui^TpNE=p0~s_u
zx{%p^4G?nY9w>9<BE~u9rNGD4FckoKq~EyF0OG`sdKC-4Gft90j=2>9JGpK?g$m>-
z;>4Wzs@-NX_UuUUR*`|6nu}3H_FH=>81q4e9!sjge{#nhgF<6$fcdM<dNuvadt@K#
zvRC()fAti%g4v1#@@!REDo|?6;c7|HZQaDS_mRHrC2oB!sR@-?8-ZB|wHI(<#z^X<
z(B`<XyjV(*gx3;rj!1FZJq|dmnCr>v-}MFwkBQ9#bAAK=0Hjr94(_=Oc^y?=qL*ch
zD;!l2l&A5syjUXTO_n~P)txPN2hK;`VmHe7K>LNVXq%?FD&FZNc&^edhVAS!b6Y86
zg|nv|F~g0~>%XV^j4)}cvq}`G@@r83pwpANLw~(_c9|0kao;pc#v)zJd-0mB`mRVN
z6puSS3}rUkH_hsOB)-!!ulv?J)VJ_m-m^r(*F08BR*bB{kP=UUMB5{zAhtpL)X%JW
zajP$mh8U`GW|}z!T4we<V!Yec7cF;vv}A&DT6evYNE+X9+ABE~zrU-1N5y%q5Y6w(
zF<m1v#qB9cjv6A{*{sm7$c(ig>Bwf5;Y?(yQ_d=VQ&qOJgJ%rb#wh;)LcDW_om36q
zRn>+?DN)aqWTUy7yDNELZ@6>Eb#H5Gp?*YE8ghdl$n)Zj+As!4s|t!OZxCFnsm^F}
z%)|y5qqV41{QKKLBN+g|p+xD0z`4fJR(8p>V2TFHH%xt1n(oI`7)OQ3{8ABtkzB8|
zVwhO7W5ocCd@|tj4Q4g#Hnf!A+BU+Rwkt&|Dh4e3RCY~xr|Tc;H?p#68cSu54&sb4
z%Oj|uN^yd=de@}AO=Ybow-oAUkA_^<l2MV^CcZfI2ED3i+OWS#UukT(&vo?Ar#)|{
zYBn%DjkZ_7BlB8w=_iZ&Gvm}kW`;y?S(~a2fh3Vuo5Y9;fI%J945+yzRz_(9Sn={b
zQ{%>SLF&4UHc_+6!A3L9W8wWkvq|QTQ-G)7e(9l(Q~jt+nPHFjIyd<qbDDTKBNd<Y
z@2ISGl+1Gg<NYMn@{p#4qTuO<GmO>6*(!p0@kK!|7(Gy;OpXO3HU@K0B-*`=zNup+
zrOGR#jxsCe-_+klU+FryirO}Nd0XN@>b{VMa(F#cFYGOEkPC>_@%(Z+tr#^D#P}%7
zg=FmUkJBGPEwEeb=<@x5MS8ugF~p%`U85aQ3u=(z6aWVRQ~j_GYK+;XmRBO|c;k&y
zIwsmid#TY$JB=}8$;lNmj}=`G$0vM>d$3jJnIQ@)8D!j}2AYKx+@3q8s%{-qQ#r}0
z(2Ra)t_aSKB3o#owL2ubgvB8Fcr-|6T##^lQ%ja?c7EznIRNzLu{Mo*EH9XtiNdk*
zUV{vg%7R5;%EKUv@?X?_V@uIAIWF&HK`<Wyo^w>6qMxgl+N|eF)FcSSu^A?;ge6zt
zs&b9~PjzvFnqf5}I!PF1AgLS?Q8=i;n1texl53b!uN~5iIDTn=2AWQJr3W<`4#qg9
z;Dh+5_9+`9x)c%{s3N$9qLo7<3=nI;e^-40CZ9Z-rkxouvC9BDub@W;pwulPy|s8J
zK=HW21XhhcqF80Q73IXTMw#)Qv3RFG>D&k1b>zPEfaC$33|FE4s`?sD4&qz8Sj$^T
zbC5rcd8|weV2thaUZVzR=8oiX@?&sx$1(QUgM*(ned)N}pkfXOnxl#(xMQ`s&jPf5
zpSP3SWaxP{p$J(NV{E`MBzUMTV41;Cr01$4RY(p4XCj#e#KKirh5++TVG>B0REbxS
z)@r@;GD!sEXvYSwu3Wn1`ENB@b&?5X1M(;k$XvSyYg7ar{{Sk2GbAzxQMih?)NIvb
zl496n{A#-1(TXc9q_ZB6Ra2l1ydqK_bO`6F7jD-%<bEmlf4F%H$}(4hQADyuFf4Kp
zic$bwFftLE6*!mfj?|Jhm0f$!B7~4_edq=aQu`ej9-O+88^tS;gI@jV()U^-vkb9X
z@NZ1Svt6gT#t${_9-h1w+CbTo6jy}*04=AsmnW+9B<a`_31YZ#5ab#*4MI56+ds(D
zj->;sZ*1>w@+zupNo2eI!tkfXc?idHsc?FCR%vWKsR3-|jYyE(B$*j2Lulw@k2^`H
zUh99goI+5Le1Tb9Ugo37*4R+JxLG~DhaOEx*AUwedSU+b%M1HylXH3dr)n0_>Jj^V
zB7N0Vw^QJ<f)@F1p&rp2O%ZDdE5OI~Rn|IRu%JgNDk#Rij>l?9!!5uDmQhYs5P0Bj
zqdGt~zn&;7d-$#986yUO^=Iy{J)v*$1-T-T?A8l3-b=CUnzk6yifxScwM^B$%FAoK
z9D+EYEN=jm#z@Y3rfH3vQ4?{;6f4^-H@@Iwl6tDPTVRINnq#&3B}tXzBxmY|yVKiJ
zv@w?>c;}k5nlF8DM_p4b(c&e13S~DMuFw;;NDtHc5Yk{O8+knQRNkY|X1vtmyGcsz
zJb-Id*D4rB8zj`JY^{kint19ar@zS^u2?0Ci)%zuGC-g&wTo+c{ips$u5MHn+MU&5
z((I6#u9Q1>%_JOmT*9gH#e~~kjnZQtGf$pmf<3VoZ=fmBT0uHuFM{~RN&9uS8R3ZX
zXg#AhMQne+FYb|r@C{m8UIrUwU8nOyLv+nC+@~4(p|yLjZ;*$YX16+^)%G2KG-x*l
z6dj!FJGOp8mMG)8wE>SLQrlats3AV8IHkiDEhWIz)mGB<L$H)5{wTdw;kb=ic*v^D
zD`PG5yYtOiYBs<_ls+lm+gn7ER;*wuwk2afJXUgRdxJL(!93N@maVyzl7G5&^gi2f
zUljP|wbKN?FM<ngw)U)~5=f`ni6xANY!A&w9h?jd)8+Ue!No@W1Fl%cwGlaBO);8d
zAPdN-Bx{zPLNR5}G<4T-MG(qh;*Qov*s`^<Mhg#+?3#imisOjbP_rxE9RC0mq>9wr
z$-Xuq52|gcE?*#wEri@c(E=*D(WPRT`5H3v`O+Vff(M$dj_yV#Wf%gV9AwceYqHMD
zAKOGyLIE{ds6y{Q!>U*e*VBnT(|~%Z?_1b$xQ;2}oF*jxe3{*1H&2UIe9jUPf^$|L
zrnqKhXxD>Pk$lu{8Lpl+@lBO0@<fv~k_ExX-C80d#hMvWRN+MrcQmmuQOG_in%?OS
z=(f{?NUeiTF|x=`X}T;Dg!jqdj;U_s0I>(E&oAFY@c9OP=5e$A>Rs;$EuLz&E4LH7
z5s~7oVr7vxIULoqi;rN7S3+6bO(|{Qg!`h9+sBtuH&<GSoRrAhT-NccWDY8sIKDa^
zd|iQE++Im25UB_cCatvgNh1M=%g$;TZV<>Jz{O28kU)0^3;Cs!wY4C-yFIO>b#b+G
zQ?Mik1D`a~rCSE3Ux4SD_lJOFZ0PZnaaEI#ZLoid=+V-U?tD`uRGD@+1X8|2xBy|1
zO;tImq>ZCHPhWJ>IK?dwV@Mg|nC-A<HPSFqReGiBK@&T;01io@-32QjeRz<eW?(Vq
zysz~G)?1mZtluQ?SWv#c^^~)2w6TAP;g}l4+mGBZk<Vw6YptR5_mk(7ucI!bQ?uh9
z%AIsP%3X;s-c3}rpu!_w50hFgT~YTAvF5Y4FCO1*R}J@FryaZ;#@p;z-T`h_M9ZFy
z3w>m=stDLKpQ>|Y01Y__Mg-^k6eSx4l(!H~X+FjUSXZR}nR?}|HtD*XlNsSy_^f61
zyGTQvw(m7tEN&)M91we~dGIO5nRYy`4$<`mvn9krco;H~kVQy$59P_PC;d3}sj+m^
zZ`_#A3dHqZu@j`oCXIt383b1cJ_%x#GqHy%$gDs!$*G}~40tsPvE6~qJwe^hD?JyM
zFi07(oC-b+uRV&VjfU|@T1t1}j};ILMcTvT-ANM_IL!?i*mA9$)Z_;Nl=Ds4y#!|*
zgHuL#FXpRO@GSn*Da}};e0Kps5OZNy<SU_+DdxDo^&kp~hTaIG6iizuAb==&uAx`i
z?tsI^QhJ`^_A63tGm+ja4t498E;n7PjP`3jS<Wirth*LC$<t?|>euaSY}26KipsC5
zq?+I}9e^IG)|#|;wxt$TAdZQu4MR<oN@YRu&x*x8Omaq~_OnzlJZ|dIs<`z;tpWB^
z=l59+Pt<yq#mSCIPClw=A8r)YW}^s><Xqz;HJTaR<x*#3L5C8TD74a}o@qnOP7mE_
zZ7i*s4)jdpyiht?B=*TD#t898#}ldGoL4tdmC95;XBj%G1G>`L33wOd^+UsN8#ZKI
zIIHL<AmH>q>AHoScM0!9g<;tHs^K<Nn?r1lQ~}tjXF|a49Abj7kgSDUf-1~7l0NfR
zLGlirnJrMF2aK-=qxD4THtX!5AM-?NmJHH^#@x|1KGn1*aQq6{Jh7E4IuppH1d(MN
zzSK&ik|{!&{!DrLrdUDmDSqi^xL7hcu4L`IFgm(JE<KfSNEs9j?Z{;zf7=xt(@8v}
zMl+h08zw>|n1Tn2DnDdw9?~XMX&iPcgI2x$tnBD^)|XYfjUXXF7!{U-Nt;)@-zG#r
z*Gof=c_nM3E_p^P<Wxpy)h@8P37$!<&!lB*77#>or@9X3O}DUwEMpvaqP;B_yLc0v
zXS(m>#-q{7%aP3VO9^BO54L%t-s#nb=*SehMX-)B$!rfbE$ZMCfmRvONvhtYj8P9K
zx{AyUfly4J_iV%fe-$K04L~Kmq0brWj>*S(s;dY25l8PPlr$@2AXIb8kpk?&R1A`7
zE+$B#XOY6Hj!k(#>Ibbw!%3&u$U=?_1KnMN1hY$QMahw4jj*rOZ&*B`>@>#Xr*U3Y
zE{wO1ZY4Qm$tJBV)=A{t*={-f(W`D$<dCE4y+)f!3^Al}b7z)UY{y*N8)e#yj8%?@
zt<0z`mA1MZim=pe35@VFSu4%f*FNI#!1$)ijWtCQR*$8BPJL9Gj+&O!IQOF%IrCbX
z?&87885Q$yqP5ntx=F(v9_!HN^+-0R;7P_h&3VmUnd6roGpC`|dy#RUXsrE3^#qr<
z&uJMbs&S9H#H4CuB0_(<BV4>|tMhfYmgHi(1W94u4kYpobu_q?Ae9_FepzJ5+IE6;
zi7sp|*5U_X0q|?vy*H|U`%H>QY_>VC5)!gR075?VTfalzN^LR70M=ho#+($9tI_hc
zHx~FkEhWwX{{WhLXLehvtg@HgT;`2d=o4IH(i8sxt1396B4T(o0un|Rox5+IDUhrp
zXw{Afbpcl0^5YcvWXPwww`QYO3!xLdVw`>hj_I3-=9<8sNuUuKx#pXUxFBFxC?&rY
zGi?ixG)Qp^kIf*;woNdQ!vnEQ_enbsH2_G?Is2^7u0360>1{4co0(VL!PuGSH6O3N
zW2bssOOk2iQ$EwNbIxnz-(LE&Q1vdSCB@9lV<hcd@C9kXr<PavD9xE;Uy^Us4_azI
zr_`jH;%4@<@J#RpQE1wg#-Do~&Af#j4nYR13leH*6qe0)qlz(()N-Yf%2s`g`Vac2
z7PVy_m#It^;Xn#l_g>VlugEzE&3<|MZuaX<ypHPHMoAQdkZbEN(Vx_teQL@(3;9Cb
zD8MB5T+L3I<M}R)*fVe8_IlHdQ+lVN4l)QLn*3Hayqc3Zwm8LcBRo?x;MXrEkYVA0
z>Yb2A38;v{<El_|%}XHcjBO*DYjAN(kZB3e6&nfz)->yFPR2`1sKdtN9E$m`^()aA
z9-P0HSdg1HB&h?c`h%R+Z>V%@O>0k*(&{kE!vK-hYSQYZf?tB1*j7Y*bDg6KcK&No
z>5GH=a}<ra8?#USLG*3Ur}cM6MmDT|3<VFMMnokPU@zTzj9DX+DoEr?E-sm6cM*u3
z@`sU8*~nf%nZYKEk{6oaJd!+6ap4%LU93EsyiohN_Nyr5W4aD2S>;D58FUND`l2na
z3r15LzUWymZfs186K8nFDsx0LI>c8ow)wyGM+z#nrg0L-yI@n1MqkY(%<Ub^kOAZB
zf?wNy;P2eXJk@OgF4Uy4vrIR*92%;a5XHgC@kTAoaWPA8k#0HaftL~76Dj0)6qFEq
znB;T?*SZwO<+h;CD%R<<Z@dFlhEl9T=bq}R42xX?PhrH4eAlviD*E2*O<1rC*M!@<
zf(Cf6QT-((-29(Eit<0?x>(B#pOktZM$Xjs8=XlaibWpSUOuUot{Jd8s|{KxE+$nB
zH)E=)yF;gZ$H{Bw&~~fI>*~@p2_i#mZ~<aC6f|%sjLmZnN&6L9r{DhNcXPquR)XEy
z=G)qJ;EYu=jG)I<xB-DJ-au7A8LK&wJ&Y#@6<H>gEvej+WE0gNZydhXTplX9bL3{L
zpp7vZQw(!J`i{ywhDXT`r;16hrj5488OD2};dGq=anI(Kr3Ywkdtj>r8+6<=flj-K
zm;&Q8Qy*<{w2@R-y4-MTA{SsY(58%KK7kbE%X=j!XdRCgHT9b|#|?v;rH1}xy+W(-
zV^?~G;zw?+o_nQ|lnCPNo<&$~_Z~<URGNxP%^p5NpAG1oZSOP@vS_awb?LlOieJbo
zDm|3C=BIaUs>K{Ivu-%eXri9sEKIIQA#;i)ZDE;J-X$zN;+=4T<MzVj9x0_fZ6udL
za+6e3`eRp@Qn-<1LxniaUfkOWSChpBW2PmNv&1$Q<j`8({nQrhw)ts1QId@Ed=(&D
zenXjmZo6V`X)TQNONq(aDzDS>-bo(&wL8BxYbE?j+d%mb6ekB4Lo5EmC6?0N2_;2A
z>@DER;Hj$nn>p{BbDfFcQC3#B7K7mV6dFl)$SE)ECOa?NrUPc9l6Z&2;2x?;F578V
zT$5Rg%ZcXIRtV962b|G_9zsDY`5IWQ#A;_&12rI(F5=p(HxBB);pC3bdr80?flc)E
zi!?6rf)0Gt*wl9dRU*pX-Brjq2CFsO!E81a;Pz{#zm_|}7SdbnS8A}V)~DPVBvFSF
zTZM3{Wo?b}y}%Lj4OqxhR@t6>&{}PRLl#%O_fot}A9|neu9np422xUFvm(GUhnjIj
zo(;{6{Zrx)>?T8#L&&QxL@s~Yky~PM(G0tg6&?5jrG=es2zZG!>li(pyxC*<s4w*d
z_W~lGPc-#zkZ-~(ohFuYkHVi6MAm5(AZCw_-YH@d2l;nZ_pU>2EyY>Aw@6PkL#BW(
z3MUz^)ve1&3%6a-5&JR2?x_KVGHDj#BPU{=N$#-CeHAzGtg&S<Le*B~Kvb_adnUw(
zfmzK$U}q|oyA8ey8{~Y~5vmQi-BHIH%KOO81|pH9=c+Kwi5}2-tu8dF1tQl=mA$t>
zc*P3w8Kr33IH@#uP#Jq9RHSW`lUcfxAD|E0!5e#QD3~qbakRDop|G-D9G<AWs;N*Z
z<k=}ASmS~)L~YG1D=W$KI6*<cj*eeEeNjs+^JODkRc<frc(vp)R>>Q&x}eo8KYIqm
z1%EU&T3o9yyz&y?S*vSFSq9lbA4aN^*zPXFw$E~r0R+&@#XujLng`15W14w|TO?P$
zYR>`CD*#-0%|{}D#~stBQXifw64>X>C}?bty>_>BB#dJOANivW8F}uZl>-8fC<QW;
zRli6fXLbspa&ul!>pxVB<0Y-Eq$uE#SAVQA>lX0h*fF;~kzP>%Wm3`}Pm^6QPSQss
z-!h#}p}}p56p^{fCpkRi)ZW{y3KpV}Zex;1)jxExAP1w>dN`^%P4W$P=15s~;~r}_
zGJli4L9IN>3Z2~%R2L{c)*`E)U?IqM3Tf(@;B+Y?2m#OYrjq4?kBR%GAh9!V*x$yR
zsKXIo@sE`*(yz(S=A<f_C%!3KvK07qJGlfN4SHAU$E}P-G~Ge|2Zds5B(~AZY)Al*
zI;t7N!#BhgV0bl~QGz)mwU^<_;O!q!$FblN#6ec%5lHS754!UI0Mh>eSzIwqGW#sO
zE1LBg)G{k4AdU@r%=o2>RL<5ciz2i>2i$q1Rkkh%G!3u`!_f)3&H>`8T~P0^%Xz>&
z)r@Ww1_r4|!LZ!^Xqcws1kmW6mU&5Ae;dB&h;A@;H3J4V?hQpoq1QO%QC1EE(*<`g
z2A75hBbpu;C_Yq5fIwm05(Cd}t}x4$tp2s4>9-0)g$EU^c@(K!c&sMBWvfSi*ARwu
z@C8?r()f>#o8--2=#OhLHjKmT6n>buW(}7BpYEg7JxMN@g|!PNMFaT}R8RVsq82N{
zn&j#+XU@N2(#Je_`;l*bXCg6@HOl#*nUU1TDE|POOD|mM6E+3He7qW-YmGBdJK~)I
zKSr^vQ^)(_&2h^X?hHFixr*K&ZCioWT-o2o_*{Z(C~Vjt@yrPR>Cua*o8n0|MDeLR
zvE1*oaFM}30r1ro=4_C&K0xzX%RNR^;!J~6>l%uG(&l-j0d}7?U$)z-CD$a<Ucqqw
z><*=eU>Y*g;1Q5cYv*tO04sG3H&>nQ<}DWUftu9mpQ=%;c)5V@9&53e&~*?>QRKlN
zRlz3W-5$epCV!Jvb>^*Nsx6XbY4gg1UPbC3)fw(B+8Zd$WQ=aCR+;Kc>s?)Mnr3oa
zED5W0{(+WJZzlzLeP<RnlsP`C(l1Bt$R`|7_b1+$9y3`lNBW9AYSA9w{{T}TC9R!}
zh4sXXwlj~sS26l_c+YEH8$VZx$8vp)Mpzf(qcqo&dykA!xA%(G>0Xv;BoA@Ud{(L-
zPg=unR7M6zc&&K7CAWDQn<uCx#8KmOSlnF9A|Qp&CXTiCY=MOEMQQbWCAPS2tASaa
zUKsgy2b${R#~f>HOmfL7yJbGPb{m8s)%WSuqt5%>WAj<R*~c`)X(yWW{{Tm6%Wq_u
z;MRnd6-k$n#@6YTIiNK=tVT!rk3x^Um)eDndKF8j#@9CnX+hhbDSO~srC`!pOpyES
zl3IpG;~r~SIx9vKf)5ozf2YX=rbPsysU!%>`yXNsdcdNtXO7+$mS+hXjFL@Po2acJ
zX{T_JsL3SPjee&7ph>99CZDId5Glc6d#1yNS*5li$&q7L%YR;a>;9v0CYz>6L~3x%
zr@F>j*}1t^kQNSn)jy_;Yjj>tU5<IJjBA`qqzrXlqe-WZ7*aTyvr8<kjfOT!OmVI}
zAH^s_(;d!OElX-hk(s$;P%Ne<lxGLAn%Gh@{{SR>#?U%7i}e(7@7$#KTDfl8U{%Le
zn%C4aHavGpE>J*pi@$13fMgoEyqf8wQ45fb*sR5vDJrs@iqjdy79QzboN-vPMLx{g
z8-&!Cl6zZ~2&*GyhZSKIYdGAEwZ6q>?Tbs9oZ~!!RyKDNMx{}<gZDu*E>%v=KAops
zU(O(imqFWB>qFCDPqy}pWSY(Xo82=?(3~9kuR%8Cfq{Wsjc!>vZ18uzGXxYCMcFQz
z%oqdJUPb``imS4>C`TV3y0wU^j0)zob`vC4$DCJk&Br2`S9c)dn({P!sUMn&5wNBB
zuN+i~CjS75HAQ``TU-ACIR<{Jj`P)Qgo|`P-Cd6i=h8A})ndY~ayK)Asu@{89puoG
z>K2L2vo9Y;yz1v%)b5D}QUUM{3Z`etcVbWGwMWzE<l|@m03pSXh^svny+Nj?K$j#`
z59(_H#`BuNEG@evnvlb|=B-|z`8iYn04U1e#wgpz>RTM1O$o31mJ3ZXON&A7&yR}M
zP$yvZToVHTXZxu16v)5IGOyhfcz5b0_PMNTQe0oGyL0hea4Qb+F(eRw-oB-|(`@eI
z**&^8e-)JV2kFM0bd2_DB9w~gV^NBvsMU+qp{V&bcnZRE)gNhZmRyR_Yrd4e(q$_&
zO|%{x6&0<fBMes<tCUTNr_mfRZ3AfTuQWT$jVA6pxFltCIpEM}iWp#EQ85)fxXAjZ
zloXXQlWE#MrTroOLbdf3ids(LZjfMtd#^}td9Q_ZO>*x-*HZ4ynlP=L4>k3N>1VDj
zJyE5g_f%Y}fXYub!PRM=Cu^gngEE@uvu@m)On9j={{S?E8phG7F`2-o<b#@%{i%oZ
zNYKfSQVl#PJk&}se-$7&>WU*598wN=G~>wPo8J`(ieFY}7P{u1_VdOIW8&E8*MVz#
z9oMJzDQ)JAl_%nH;=Y&%!KyD-`g+@1v1MdmbPtPSw`jF*45{>I&w))^?D_g9o;*mo
zC_5D;?Zv#zkFWv<BCNebV=jp!+fKOWf=6|pEg5{MI6iCCW15;$M<z+9OqNMo1>r!0
z&MLlKvB_ddJ(@ZdVoo_jL*K?#c4HZ<Qb02LuwioTjEW4XNDkAS_e5&OZ`?E~^8omv
zBV(R^E7lEGz(R?#Gb(aLMzV<;bnD#_a^f}Gry$fMpKk{k&lIeK?xU0T;lcR$s&lwX
zPm0l9I;E2C<N?5{8;4mK72tWQW-<)6jy8xs?4PRif723>%p0uNm_aCr{97dWtrw+r
z$)LYj3C2$by#D~K>9S_i$|&r5W@tkyz7J`V$<51Lti%e6R1!YdV#2Jnq%&y2-M&S0
zRRV32mGheUhbgu6dzd#k@DXWZ7F7`NGtFIH2DG-^jg}*ULD@=(p5ygJBMZqvC*nG)
zGD)|{Vu0<hF67HgAN5uimlrn&+xGCa4b!}GtZ1OG;89WCCA5Dm0(z>X*MwhIh;FXG
zZ8E}Q&VLm-21s`*Z8+kU3{vJ<ai0047ty=>ap2>+SIIXnk}9;_LTRra)_uxB<Bt@#
zzMQwZzgx!bYS>xE^83o5Ki(>7U7}1k3yObr#oRa*a`-94AYB9lh3c#>EtW`tE1Y<s
zOv)xQf(quW^!tdeKZyo|ZSn~wm<5z;`+~bR?W1RhKgX(@YD0F+Z~>^bNm-yKA=lLn
z*C05yHd$5(cp%gk8kAE=K--Z*EHYkNxc4yK0Yd1SG}aS5(=l?!o7+^|Wr@WqW!?42
z$N+#%MIF3Mh1>#alhqdYv&{=yIZl36d#0jAWQ#nToDOPA3NcblTi^~^#8ZR|@S?rD
zN5kzKzUj06)tejC8e_oH#8xBy5kvAzT~P)5&9iJAocN-x48q_1o#K++4ZJvzWxSI?
z&#IK4+XzVeqN9BUw*DxLnW4Pg%vclE6tG5R_nAO?k{5z}9ye2_+Ne(8Dmj6!XcJJ4
zS|S19_e5zBdltmTFbxfDaSZabZbk(e4b{9ddt1WistWoZYNJ4ROkubaY|Rj5j(D<o
z2Bx}=WkZY*eA6vqjbI?2MKz{XPia{!hTVu!l_raV1$ceJbDtGKu3b#m!U#vl?yRAm
ztu+1fN!Q(9EN+wg0^%fknoW(citQ@a;t0%+a!-mT3%KOB_Z4zanu^wGO~En(7KON{
z8VXH~xt8JBrrdsLXl=tv70yYkJFB~X0LJgC0ivCs-5(K62J7gZ54%;hPm6({%~P^G
z({jgX?v1#&X&-wrC+eJ$dt-AgTLzLVZ^#wQh=fD|E9B8W*h><~Fu0*^@Xf%@Sz7-9
zlEAJy7^5dtHGFKOxRe_=+sk;Y%Os)85uR&FaT!UOKhkQd?RHE@ir<1&!YOH3Bzw<e
znu1$-J<a2qpWVSDBA*`YZar3=&2mJ%7P?dsrN6ja<%(qP3Ofo*2h2rqYm94?lf`9!
zy|zD!Dx(rc%_+&r;;yY_iJ{3)krV=q&$Ap+*7783L#Y1g^2*U89(f{)MQe-^g{uW9
zSNsE?#Rjb%!7Cm!MOtFb2ySYL^jS!n-YMhxzsj3-?8%ZbiXFA6OB5WQsMt_kLK%++
zk;TWEAU5A;vpTxALE?ypZK;~CSf!faN$-^dwWB4AV&zVL>)-UO@HcLRmA$}C2QX!C
z#Y|rVnrZp*;+L@WLaa%t1{;b;LW6-!Qfd%`Qm}&h)$Oih4vaC+itvBbZ${l{moISw
z7qxSdfz^Er76>7zJz~b*`pxaGV^@ubk=1C^=av~-E6D{lO!-m9VhiL`y}igjS;van
z`uoxIXxA-0yk)J}<PqYrH!Xq|A+-6gPlG&i$8=6);Na<z$U#DkIp|dmr3{fyNv#dM
zKI0a4#ww>=B(T8bc4_h<3Wi2j$p<E-3z&}JRjK>-?I)8?d3T?Z=Bfb5*n2=Sl6;y~
zh&Rbd0CUYE$VOLh70vMM@Mtm?Iy7Qn;kX}kw!WO3Sk+SA(Mt{ACIhNF({|SyysKqr
z0Z@2n#d}wzJvnQlS*TPEF&`%LSaq7X<BcxOT6_;9{1iHO>GhR{j;R`t+<~3nnr@4K
zHJ#DZ^$dUx6^(C?$l|E|OQOYn0eHsQmyktpC6UeCj<jH+sS>m+?T73hMK&z^nFjz?
ze?--1wYdKPr)nhdaI9-bA`EVioc&TYT#lWME*XwFrG$V<YKfK51Bz8{v*wg32iwY3
zyT~<V17`#pq(H-(ItdD6Jm#VyZnCVu5->+p^>$X;O#>Tl<Qy6;95?{?OaQP0u0iIU
zpkw4S{m_A#2qbYuBL`fQK!snaG#f2vPL|T*CHamR4y)y#)W1Vs`eRam@iSX7%D5Hv
z<V*u|)l~YoLbBI%*)1-jRt!EQj;h=_UMX0aaV(0DiHE$6m1ZB+9cQU(5D-%0LHNyU
zeRt@~pHJ$q8^%lo<y#&rHr9ZgD%WlhhG^et<w?&JtD@&l^`5P20Asy>Caz%pL%9o?
zBdpXG3}PQ14K?)kKt?#KGI~auZrlr@>N<#ZBU*iZB+LFNxvE`n)VihoZ3{72&w)c}
zmIHWE*{c`R5;ol9a5ZKxNYi3_qaI0<)O8sZIT*)<nTgtasNUF~LYmjfrhvz4@Oq)Y
zVnb~!jMmqT#b!!K7;%byg@wi4%0UEd@-e^wR+Y4gZm#3Dw}`Zialo&1{U-f2w$fuw
zM^cGiaxxT-t0to?aI0nbaLXg4Xa4|BJrAk+cGfLYY~`>@ek<q?NZi=!7OG-ZSwQ(M
z3ik2I7q(Oc#xaVcnhTv0_+DA(+t0`f;Lkgpt(|z`QH>+i5(QQ0Q*I>-9@ACY4z~uU
zWEog*$H-H4TaB?EXf_Hn-lW*&i0-oYFs!IihI3Z>oaNktXegp*ITcxFNT|^CwHlFD
z<P*hu4xFtDY*ATAVv^rcjFFAiv#{nJ*~zO{KxJpBE=+K3@@hRM?kQkYQUebZFRb?^
zxsxOTRo<E_J|#!_4(K8^X3pO&jM2i`C68+igH`%$!JH$E8oq@_+Ll(;9v%Aar|Wjs
zU-m)2YJZm6@SAvn&$t_d$*;F{iwHFfNiD7;4;zdSMSR`*r|3(a3TbX_A}wmfoPpJK
zJv%%i_A?%<9HsI+>dd-b4{MR04Q({>n`7=V1dla}wV&INVR}5)lGgF2jB|lq=)VUw
zme3O$5F2v+)N%;sljL@hP+Lp{yGKTr>4Hg~>cRqQ1!He*f0a^d5#d{$gWXu&Ke;K9
zdtU0cSwpiS<eEl8yGXb9uQuc04QOxRgs4St@u=pjbZkXDidT|&t5>j+MKQT58nNW;
z#hPC}d=-|8Ww_d$sOqf0Y({a4we<f0rplJw_~Rml)DdjtWe<`MREbeWS?+vvAL*;M
zv%ZL-##@^9yA872#VI)~px1$Ew{WH8W>OSqlU~oE>IwTON;qZOFhQ<Xz9}?!y(Us{
zc50Cnr_dDH3dAx<3-?u*I@Po`<hy`z)noNPP~Bd+jut9_);xG8mC{E2Mz0>8H#Tau
zEq>n9Dy|v6g=Vk)L3wmYLQ#JeQn48yd171hL`M!6kzH&ap9pg<PcN<Y$<K&zh65zc
zmL-pz)Zupw6#!8&#HyGAq>ds%<GScW5?vm9HnLKDutb3W03a%8;cVuK5s(0>V~D16
z=C0Utr=G#Kk_g8Xv7r=faqxaL?`3;YML{Dz_jUqfIqJB=G4)nn%Iw?^%j&sp_ly8H
zRB=o%bc*j|YUebn2ss%)-5SY(w69egN0Y$7r1q5;V9fFK%DekZd&OkBiCswYE6#mU
z>2|VrxwcYaJ~7pLvqYnp82X^Dqe)_Dr9f4<=BaUT<sOSiudXC`Tdv61l_2;OmhKdM
zhX%F2vd~`2Q*jdJ6Zq<}=a(Rwu{%e85>i%y^;vex3W3j6XXsy5UwUg;j^^G%2I078
z#Zqe7+`Q26h2*nyNs}6yrdt^}yGPtVr{1x#^*)yz(MrDXUz+Ed)#MTRuZVw6y<L0h
zt!6o5mA#_hCC?T0*Q32tVXx^C-NiZvBjgF{xEhT-u*>juFy&bhqR%wf1d~)chpF_-
zTlInNR|m2UTG-#(UoPuumHz<VvbeNdrk@Fupd*55-5hwX!9FXpIz7^kI8(bh6%c>;
zsblXo5e@?<^GbTfDeoefPHGU!`uEb%>$-dGP$yB9HQ{=On>L+1me*0Tl{n5T>HfwI
zVt-M6DITw6^IND{)Mt-1)6i>P7q(p)br?6RU7i~gGN4uHo+>+sFZ_te;*Wbqv%70+
zkXK>HHCL%@jzUNA`>#zFq^%sLsG_@BV!V~23jY9gPjkEX1W2SP=ZdwunmF#a!69IO
zkTeX9?nunz8>wheSz0pcV;uE^QBA%n4;csl02MdwT(NaIQBhnoHZXYeO2SUz=CTKA
zIPR%06o>x+AN*F9#J}u{h2Yga^a3<#l=Ggdtb-!5*y2pL2gPaqC#N*}gmdsv8qCPS
z)HXJn(E3ACds~n{(dN0npr-IkXJ*|SkGi)W?_+oST`4#$F^Y|Z6UJF^81qc@ywG1+
zpd>IOs-IL4!#31Swel>ntgSW4^c)Z2!BKT{c^e2(3rF`?IvkIHBqUQHWGVpw=B(|Z
zhBXcVrOPF@sIzfA_trLpb;GLuTA=;SmHAT?ipmcdpf!yy9a&GfN}#UNG*~RuM+B!I
zbxzECZuuTO7S{nqxk$NuU<#|!^!xa(4AK#XJyrBpt8TvIKJ$ugv&!-xj~U{s-?ccQ
zqVJLMPwf%z;Ya47*KQZ~PSItKIK?KtZ6x+g6zp&^F+u2tNo_=T3(9aw^FlF7JBi0=
z&uA%qa?%@+$rwCVgF}d{j1-VFR#!<1+p&!R<G`S_?5pr`R%FY+r9pCaY<2WEO(6<+
z`>E{rv;`lN=AU}f7_yw#X@hKkBbGhYTU843HmDIZZ#P^MM-#glb?3!Hc{C|D!;RIQ
z*7aq!x{XsMnDs_D<u^#OD|cp-*!KwxIH+zD+Cmg&lE&uZOJ#OlqZz2|^=me`Xxc!|
z4lz+eUqbl-lS(%-d(ukCeu1Jbmg2}_Cie&Ci@uSZ{{W3RG}}Y$AM%droaIy-zRpLQ
zM%^g*k<~(rY|<D?jmOPNaeoK7?ZuMW`l&7LV%%okmo+y!r@*wM%Llqh?c*#s0)&{)
zac0b(M-+YY#usa@;q_42M(%iAN8nM9R!!g<9hiknPm<)-eyJp@uEwaO#7}jrk~qR1
zvsBm77MVz2HDq%9n`2}7GS2IKc0x$cL#nOQrkZJ39EJSVutL^&Jn>a1C4%Q@2WuLt
zF--<Dq~b?&Y6af*9DUR}v;uophjGPQ-X<-J6V57@!hdpC5&~2jzZ;WR^isKG`XY;K
zAdb6;`>CY4jph-7f@zXnKnJxSEPA0=PPluI+%x0oQ#HBnkrGMr81|7YzTxG(P*?X-
zFToE#ihalL1c6s1QWRLww1X^aDEVPr5!lZnpYtwBsV}Zjp<ay@YWD4H&B0(Ql3dR-
z3}T)!-768a-zZx-B6-g6NU6l~{_A8&L|=6ZK+#4>PHJsFW;uz5b5=CG2HPRMMP|tE
zvpUo4pKAA7O+-kyAP?edlT@?@Qs<nC)2C@QWpb|tDn#-=;&DW^!p68bq;OTjii&%1
z=NbO%e-E%kwbNxT*j4zSH9U&D$tQtJqO>vFlq<*`)E5qL`*}VqBUd*?yipVqp}B5)
zqFo+ifG{eh?Pc5@8x5Xn?!hH!279N<l2(|hv9{1GO_;N~oY6}wpLmeJijV^X?(VrR
z8sW+!{{VGElYEaDh%Ic``*En<_fjwYlK%keWPMZNwOHGJa>lFm+i7Qy5lB_P6ctI+
zd;z-X_oT@`9t{$b7U9kfGF0}?SE`JS<AYxFqrpB$-NBK)D0FOb=7@$}prag$LvQX9
zQ1eEwpkLU<=d)4E77pRnJ@-a-u;!FGJWwYjDsVY8qYc5Nl?fSISccW-x&Z^#wCFFb
zUI~ygFvm6E->5#0xzTQ3co4O_9D)Z`^g5pgfz|ZeYx`D$bPlXBf;z1_ZA7q2*F||C
zrm3GRjln@2eb5@%5yBrI%Dor$1JV=e7cDd~lWxb14yyyK$BR+8bzYMmXy%6KoXO*G
zbj;aVWMSZVr!mG593Li}@;|rn=o)TQZd<cau_$`{qa=}m)mnOA)AyR~>cbRlBM0Qi
zs+-cDow(NS)+p74Ir%kvm!|YvT^h+@w?G&UTgk3&vs$q&vFz8U)4Yz~Lp>+y>rE2X
zV~#c7kCS4rNcnJh^Gpq%DILAP_pSt{<n5hU#U)6aa_5feRX1{K7*OusdZJK*Xbe$$
zmqCvD29hM(DvW|Ei_`k6+RSwAM=HSKSl6Ja$jPkls&qJS;b|dIvna?SnLi8+S=6xH
z8zaR=iGh<;KAhF0w75EEr;tIyvsSWLM!@OLddHd#P;3zyvIk;{-G%z7++!acQa(mJ
z(6Uv9K`B`?oQkl8#GP<zl^+e}jkdTT;B`?1xJC@S9ChZEehq?hv@A`$ACRfzY>kco
z05k#=q%h!9fj&h*j8l+uDq$caCZP(iQ+j^KU9os>VhnM^V~}gWeO>7rjT-hubpHSm
zZ-K{(`bAvi<ndJ=r_pV-yC#ZN8?o_hby~E#r-omGjQAE+`95ip8Xxh$j;X7MoFGz3
z6{Gc5g+7gb(aeljJTV+q2$f>E5=Nk!^tk64#WZne2Nz5yPJ|1vxa+Z3R~Ex^jh_?d
zsVyEsb?%-rYX0Ksn%Q!=Bdk@a(i9HrDEDj&$Q{*ema^Skq!#F2LU1rB<Xel|m4e+1
zNXHxs^^ZXMHa$Kyy}Urvo<Jk2!>rZE41Xq^7$ued2>$?0eGd+w3Sa6GhPXV8j;qmQ
zT#yuC3Su1LF@Pw9Rs*b8nah@0Wx1WKc-A#YctS=gWr1Xck=G!Ka%Fp|8NL~+hB7xR
zb)jDV>fMjDPsv4Ion8$}%t;fC*!e9tQ;BAQmBvA=CC~0O%i{18?dOq2I^mJV`7dvz
zCQ3g>0!9GUBHl-Ifz<QlRlbb)k!Y^PW#+SB8qH^oeo@rg9D-Ot9ggbXPxj}x*w`S7
zqG(@B)R-P2W06*-Bz}T5izu$G9vN_QD+6w`XxgEVotfgj8dphU-S=64QdoZAhabs)
zywGEy>l??sof;vvSCVU4X)tsGvc8?PXl(#F4O)vR@PmpBt-E1iv%#wEcT2X_EM>I0
zj5;{SBCIi8-v**|My&Z~^*7M(>AUBaDA}#tk_a7ELrb|Izzl)aeRJxK7SmX;lGf@l
z!G-}Ns`;zdUXZ!;#;qVkEd!jZV!OHxZtsNqIl7D+eo+F5kT(O9^<5?0Xb+b9pq6zH
zh9yQQE15HLHk^azy8DbolFutlb`B3>qG*{IxTRtuA;b6GHfe!esmUgVkhS#6+nb+y
zasVH7X?=Yezg?hvK=)Y@?yG!B3+Ak#mwY&4IIObl=jV%ztly!AdrxxC;0XfqD+PS=
zHlX5n=;DfpR4Es?4gnkzDz@kuXA(=1=QNUZtgaDrl2lx`r<QFs?pkfTm*dSd(Yns7
zWY1wSW{FM}jRLx?lNGf|54OH4`%Hi^QWmqUYf$a34S97k&_b`0<!&dt8Fx6Ntzcq6
zQO!qTYFL1y6?0_)jO62r+YC{Hq<Osh+2)nWk;7~k8R4j*2;)4_CJvt<lTsun9aYgs
zKQ2dO1O;$F;MB<;KpRLjK#%y5&M1Y9$<V<R#%C*Fq5`BAAMH;NhB*Tid{(U>$rz&J
zu|R<K)ElBl1gHB^T4GZc0ulM8_7xChcUFeXh5GzdQlJBA9Z<U(cx4_~6Gk}NwGoJe
z$8}<eM?*B%h<F^+SdJIS6gJHA00`!rb7;}Y?VjkhQjL+uDYA(q`IF5KY-FON`6}dz
zmnwOoZX+8y=B|WWl&g#%x`%8k&m4=%92!X)u)3~H-lt$L>{=;sLktS>k5XxpY1*8T
zF~Vo!Yu>LTF)2~<&3X6gK9Vjhjmj_0DwXkPqtNO<gFK&6%P7x6f{bo&>WaT4M~-qR
z7$#&pz|A{5C5@zJS=KfFMAxT!T5Iht%h`fy0AbDzVZASNX0ro2e4C?Qm!RBRq(xbG
z6Ufa`ktsT58M4YeE(t9~&BTUBc?%CD)|b+nwdR?AkM2I);DTzh)^$w2zz5Ym-Q28z
z1pwx%$&M~HMObo5GEUE+Y_0{xoO6%$C^WnGHZfE_i@yENgA*RtioA`%KbrINjXFJ4
zCAlU{xW)}V4mhaPbDD5IDF-G7lmXpFna?#Uk>-j3(lRP3aCkrOQb@r@MGY%%QbC~D
zQR08BF~<hBrrki@{IOVxJ+lJ`UB<Q_t3;i77k8S=-1{pY!GgqBt@P*q!n2L2{{X1W
zMx=IKF$0X$f4EJbH0GVEBmU||9E|Z%V`5>)CbqLMKq??3a2vUxCRqKi<_j8qy~JYV
zthp<U3W4w^C08TGR?tfeBJX3hSOO}d@g1F%wkqn;U7#+i0s5+)RDY8oVB?yuYk`qd
zc5nirq>g8|bqd|ok}?$NZWQ}9gvzDH;!S1B>O7X?S0sBk=`5}+N4iM|s@ZDri-|ys
zf;+5V>H8!$$e{2?6|MGfBc1M5vl;Mf<i4-Ys!bn5^y^rVETyeEm!amRi&9Af;QVSy
z5AULArBDf|S4m4%U8J>QsI~I!*SQ)iR!QwPg~1|%_O9(q6Y@dLNoZt>AmvWcOBS&V
zq{kq@>zc~q`J_BsT@SaqX`}f!A63%d$7(rjk>FID?LvHUlS8GYx;dV4yFLvnQSutH
zRlfbwXOImaWdao7U{I+IyO3kTkD*U{$nB<BHvn6zMy=FB`a4{>{hgZtM%;30lS|a1
zmA12hKIp$tSX^pxh|$WYoK=7QDJ<him%qBvjxgD6@=Hx^G>8LQlC7R93mdr63K8=L
zyG@4{+czFXSIccAci?W|nx#i|k~>wV5py1HKXHOiC}F0>eK3+p$H${q#{xWU@k7S4
zE?G_%jAbbF!MeqiG)e5K!hwpSi$;zuQ}=3El5%S9E2w3c+i{X8pplcs80C~Mg5u-L
zA$zeLWbDob0d1<=-O9_1V~RF=V<*K=9%ygc*+It8tbEePZ95qxPA%=v`Gz-8)5__@
zS>01bW*qKW4&SO-V_Rh;^ZBD_S4owmUM!yMqj>tOt2vSF`r2qa3&n8RUDXBE)Smc_
z6AF7Y%{ef?qD$+6xctRUX*Iv?%g6yWS#@S4yhm3%M`DQ72ul}4P!8TPQ)GBn6!@eS
zWvIn8#syv~Yv6&@j8#9Spp-AUD9Nd{$)}1;L^GOa1;1=Warp(^BTBna<YTI>65B-H
z#>_vOvC&<c9n${*ELCo$3};aHdgh-Wn8>ZFbQCNi1WkdO8sb?Hkc6IU8;gm{s>c5S
zA2e`iBemRlY;#fCs||T0H)@u{dS!=nIK|&T#cCL?qMlY?1H9AckrF+zf8w1-@JGO|
zAcT8r*v&)im5@o|h5fwp%kIbs1FAMAA#mX0oyTvIBqim-6#h6gHLPy3d!&478~MM?
z5f?eB=AD+^VhpOpQ${X<`+5^o9^edzHB~-Z6S!oGxPsB6w=T?019b4Eq>bjT#QCIE
zHC!26$-+sGIjL<*xyu>~U>a6-`=)#5KC7#;)gmqp7MxI)1FB{*GjYWWq^zv|;W$Dl
ztH~BLEDwsyB~zlxv<oz!<?o6*8-|J;gT+xpat!6A;1k7N+eEU)31POIEH<u4nz9%#
z+Tod93V?f~pqd0z?XWCrGwc~Xl~w-$YJIJQcJdi>xE}_ome1&WX%R~`;C;%ZEm&C3
z1c~z)Z#ki+y<dDp$~OKfw-;7$jm&n^xb9SuI#$np+%xhS6%(cjWdwdJ=bb<Gw^z51
zWzDIPhi4Q^{=ZEY1e$yQ0L6V4T1>0K^Oc%EXS@7Z`OQ8FOl^WrE5MKI>?Gvr?hQ>J
z>&>i({{XO%)qkhRybbQb`91dLBPxbk69qCHkZZ=RKVGb(Y(0#dXxII8(I*-Gi-S?%
z$@E2%KWDDS6_bO_Hb~AgJFh0R{cF)*gKFZfApKy_*bj0B0;0i@{{Rv^k^4Oh{{Y66
z5C<bQf&T#WtLfPf0|vN$sCs$0_W-4MX1oli7v$P%b{5)&vqNzjvJvLI8}&=l66voj
z&_+xLk%85EbRVfcoOH>%KtH;RSM`^p^*a}~p6(V7G0k6tCR`5E;7P_aRL_>ZvW`@@
zXBe#?q<t?ww|1nV5UKew6nCgJ-3s5-L8H4zwPxMHt;Uz??@MWRi*Ih|xE%g#c70s7
zd>1Uuivn`_J`Fa5quOaUi3Aaa0CI8NSpo;dRz<&1bS7MT%0J$kzo<T+9Dd<{=D4pO
zNjqrisX{7~HdzCc-8g*MXR5{z)DKUS^SVrbbV7ch`gCD`a+v$g1&V(}-ygGKgNzQU
zSOCTiWEa=ooyLE5nEvTg^#jwdkS@`G-lw%cpzn{_uiSYR9`Ta3mVaLQbYKhE^ZnCX
z*M6ODKYJKI-4AYmMBg8>e^zLb-$Z7FZJBulP(GN~UJw5OMru4d@Qi%Zr1j6Iy8ZNc
zKboNR9=Yke#1mWJ#FDQ$28?4R!$fk6@_HMtP!rC2G$RrT@@pOGkJKF`Mf*$pq&s+5
z&1fR^7K3tkMW{vp05m0zQScbfFUe;a`0g~|aKmZhtAFbHSqB&Kf6YD}M^DB@<YfN<
zVv?Bli-=@$K~ieU+Ca<6=Cii?ov!}?jnsehM#Ft>MpktH0FgqdmR?5Tcs$eO;{|%E
z*smaQk99NsiY6<R9D9mK_fR1~tB&w$L|_PC6f(N!aAhO=6)2Gya7KT+0V{o5pxNu1
zd&KAjnE19Uz;*os>qgaD8PJ3W;(qJtA8@X6NBq`*)*2PQxnRo5qEIreTeNz&hE)18
z>NM*j<Fmo!x`%GxZw$U@yJ-L}LD9aY)V;e)MJ7z+flbtOOT^WVnj<1Y*bVnyr|1tz
zS?JcQG|Z21+>%J*y4sy|F~Z~I!HZ2PPMJTTJtY>I3f$cQ_XKC36}VH8!0LsJrf?)&
ze`1MQ5pcVg{%g);$t<$nBe4iZ3ZhK7;~mio++do4HjZ~L59Cyy<ZI6L{{Wh;48m09
zc@)w?{;B~mWBivN*sf^<HUlm{u|$M7S!{vTX0@mQCoA1*91h7J^Hlo0LPR7H$L50y
zF%Ht&PrW~mc@?G5Z&F~arw7QYYxsaCkbmBTvzkjwp(JPH<YtN_x#adu3S7o8YHw4+
z?&+pgT(Wan&r52tNgA+m`RA(F#d&D){Nzj?!KW$mXEYn5a~8&2ZSZMsU?%VfI9~#z
zhFFHLD#MMXxWyl;AV`*9BAdmI$*s{r81YuH9Iq9gwbU(%ALUSL_QF(=K}H6W%ITn@
zIHr((>GBmGX}g#1p$Mh<R#VnGCBCg?Br_l<92|98nOmOdJEabWnKqrFT0T|vu7h!-
zUp#W5_Ve*-%^3o)81BBC^`ED0^=k<sl>vMmt&cVHr>XRNjT=&UE>!FX;&I(~v|7(`
zZI@>^QG;hIqO#xyUz79oMCrE8Gb$?NebU(3i^d8R=kB%IR-YZTK|ts3t<`GQ6-%&S
z)4Yz~MRdA&GDQvtKgx*IJvh4ox07y1H8iceQ3?*-y_!0Al>i~Q6q;t`jW%<2(%YG(
z(H51U+CypW$TK5(tnaMtTEYfYlQ`<H;?=@VH=adjJyCNWqpC)VNy+3@vRA>5IciE@
zMP`9(F2Orwv9Ck)`tN`Yaw@Y&utbGHUln<xC$V-{7zf2&jw&mIldaS|(ruUaXc0jv
zN345};5aoEvK9c<m6S_^yR+3?a%9}N8yE@#?W3Vhu#?_uIMn|D61^I+wv3)J#TF!a
zbPW_|Amf@g2txduiXuC32I4BO)pt@^X;MuP`7czCd>7)=+>&OuLD8ht0Fm&Kc>LD3
z+d#C9K=#2k^Pi->b?Rr;5dP&-2;Un|n)-{=(~I3I3x^|fpeC|=jh@Q}j~*zcMK%8b
zr|qST>|L#nD+{UFwWZrbFJSjxxpGtvF~xbOs^>}dhE>KF%{(OAFnXq+AGf->DmDe{
znvKxs^F%oWj1C1be=n-gndc=H&^tzONv5J8Ib+2V_#?U=Mj-v-qU1)DU4z^!Z^D8{
ziVEi?j^WK%TwE5$6apwK$ik>{+0S)9v1IP{fXV{KSe&1#q1Iyep^+JPDF=$Ty|{%=
zH;?(M%ZrHE956VlW|7m<`<!riN2)Eoi^-$gj1p@;rBq|?y({$tNtWvErnQeb9OAK7
zUY@_3P)KBf)k|{5rsUD;vCiU~B=pN$wxJNXY%Xinv}-V1c$44;LHt%?Peofmp@ZST
z2Q{J4+Dj`yC4IngNZpz9NlT*PVh<?!?OGF4ziT-WTbT2W)cCKVGJ~87iu74r0<s<1
z98yVIE5{_I$?RT$k~PrcF-#;@=Y!R1VSJkK57WJV`$E*sq|DD`&GFBQ_Z=$kE4Y?e
zoHCK(xH<9466EywGDdM*OSo8(Q#Vxv11dh~h3lHm(Wx;|k~yR<X<q?yDkI45mGCkg
zTRa+qb=ri3QYr9hvw$Kr7bJWh9r~nE_3Sa=Rxa^^$O40k)qbfk9;I=dk0P?J;%JyQ
zIO@HIfq$_RiKzYT%im6`cPPgs@k38AXz)`f{{X_5QDGhXJ1$7^LOhJbkUOo6&N?{5
zseE!NjARTlIH#*i5#@Un)!xmP<NKv#MaGc9qHX^GTvbl4yCgjvnzPa4aIDS3{nc)-
z7UyOSxqlRr=wwq}BC3|-C&fV=p46zod8aZklP4s7R5wlr2o;t})fOjA^sh>4_%JGR
z{0vvIBD?6JiR7+p!T$hEWrkbT5)8I$-r~E49XVrR{D&3uFY-)L$C)Uj+j>SvJZafY
z1;AfD994u92}mU7p=)bTZJAhZJk>n6^4d-9By4hVn&7DKUlX?Cn>8}rnIjNJ2j+)+
zSYiOmgP%2BZFJ$+D0dpXc+Knq9k42iMZwU?qpecZklY-8Xp7Hj<Jg{RzI`~u4#=hX
ze|0sCGb9;vk}9by@;_Xli%WlO1}&N%?#*s5l2iVg7Av{ty*BC&(dMpgTMQ86{pvl?
zc1Ozmj*sFn!vd@IFpj{hba|_5yevnN)nTqRhFwwYk~U&|(Zva5d<GF!X2VWpF#tKH
zY8J=$NhsiXs*Mur;9PBS@%pQsQgGJ!Q-Uf@I58An;FnOa7C%)?Cze4XqVOtfOW`;X
zvB}0Ml1A3<N_578e`MRW(V0`I$E}qpL~MJl1@p}XgUGITD9s*_#ONJ>-S<&k#EgYc
zAn{huB9mNn9nJ8-y)&r2^{FnnVfRMQY9)NJAM;UKSpME7_OPJ+Rc^aA<-9wsw=|zr
zyHw}!;5M(a(m^CBL}xgtZQ4tcR&^i>8%3V#TX6SiRlMepYq&xkm@o7yI7%*wV`P%n
z(Rct?DlOV>ObQlTXShD>%mDDUEEcoEJ;iT_)kc+f$SD$ty^)6G{nU4GtdWwZB#x=q
zH_?d6ag29W)*7sGT_0?30)mX1w1$FrWzK~WiZUcz9~8}2E=kArLEdX3JDAX>38Q7W
z6T%A&aYmeZVof(IEA1VlYz&c1zbe^nxHNUBj|6d=r}Z7#iG8?NE=^mFZ<hi|J0r6|
z?oWKtGod4II5h^Fx*KnG$0TIbmU@JDVZtt1O<5?)+YFj-gQK&8HSgrz)QP7U&hT<5
zM;8)JouxoEEcbUvp+VxO%j_+96H&Vm1w-HBoh+c)<yR)16|63v^v8448c5052>c3`
zfYqu%P^Y-0<L5%^HmxfwmMT`Pgl`0!@x=*x{_Fi!(UaY1u8>xpDSJ~Bw&Dd<-Nu7@
zH<~L?KelFR4+e+S{$w(J(?f{@aq@~Ay*+dBJXLhoicZ1euJs~T9l-Nc>oDDu-E{Fv
zO<1WfCBB;<{ifXV1u|Q3@swjt((YAqjKGuCPay%zRSmT!TSaWPP|7xA80xIF>s`sW
zc>qvCXw1i+MH-UqT&*@qNvbB*d=ovIM%&T8Uv(0_$dh5qFWof^&GW&>)jcnxSN7R(
z)m2OT2{?`fJEQ|A$)ul5x4lp?{`CdTy!VU_?TJ#mO=So8{#fFLKM#^K0Bs>)%-8@`
zMze1o%&LMv6?t}>Ajuis{{V`vx`h7N?K$GU*(mUQp3KCS=ssi&j{>?kj0^<9`>EuM
zVzV=O>Y+`A!0AtBs7MwxZD!<VpAyCxo`|NYNat;hxO6G99gWW<)S_83I;^V2emSi)
zCf-|he{5p1(YlfI;}v_RN*>o}JPxYJB3N5Qo3gQ}#XQ3g#F&5|bkN&|N#>=JKw<&9
z6>iiU7$JZbRf$TPgjmMWF$xAcqvK!kWfweiPyp?nryq)6Z4%i<e`@I9xCMTwV+<$x
zE(tV#sALn3$2sDIXh~LPZbwy1icFSs*~UR&yc&i(7#|z32{kpX#u1gye-#TBV9(H@
zwF21L^!s&~C^=ue)r?v^CN#hYG!?VN6#IwztKB9<F)1hgso@0KErPy*4$OniMF*$S
zOzk-$v==U=0)e#DR*Vs{rv{ngi7k|JXdpj16v=cr(ZD3~D^GBa$YdY!LMs^;4!n-2
zdrRm$nUcTJ3NR|>s^qe5#dnd9&1`j0=^inW_f!+8+z(Yt#TyRhRhuTp15&IPu^;iw
z>JQPYc%a-z=7?Kz+n0g1mEnsf_ELZPO-4oJpYmwCF{?HY@239%nkrc1MaVgCB8jpp
z2q%F-V299s$$gGnU0?vw-_6hFrL#{^vte)NAMaOMdnBsADk@Uza6O<fKC0i-WBL!f
zKeD1V^&+tcQJ4|W@~1_2>SN046Y>85%CFS4jtO3IM8gU!H~<DTk4cI68D^i^M-HRv
zv`#PO{{VKOru9Fn?bwC9kdglY%Cw>%aj+LWc&gn}z(T={Y(sa&S3Mpdp_Y7~Wmo?I
zmmaQBkvklIXuB`eFH{vNBNP7g6!0<@_Tgfu{{W42F@=W)6TkYZ{{TgY=s&2)yo;;)
zk6OLN&O~yKoqM2@T=g~w{{W<>0RI5;sphnl#$?)XJXA;r8-^;yq{Nj_uRccmEv;@n
zQug9R)TSi=0P?A!x%GPxqfwVX{<TZ#+maN;!N*l*8N|DQ!1GP|JTLf>XUX<fPkrkc
zj?emxryu;Nchvo7jxS~-`>hH`?ws%7(U8LNLfH!ZaYOW2YxalV$@XHU*S%*RK)suf
z%?jSF^^|YT<e>imb+PtRKuJIvt93gBcK`r0-7K^?zKQybpJsAjT>8CuYq>}tMuxcc
z@2Zam=1hNeVRdMcvqk_lO>+(lD@VuPDyO5wya)9eKFD9zo}z5-xqtblC#-eyaqmC;
z)H7Se4n;9y0PX-%{+l1sJ^B5fvHD%=$)<&&xty%OlihlCrm-f`x>85?UpZ-8;*nku
zLzCjYhtV2NyKs@oc8A$L8s}>?iZ60z{VsjWYdtU1it<cmCpkH-P2(iCn^<#IUY@e{
zZN~5PiWAgY>~?M;jBbA-x$V+6)s<SzOKo-xWPoVRJ5Zhw3P^vdqq@7E{$R|w6c?*C
zS#*6B=7J+5;~aRUjCVRh%1Hux`}L~l)0&^`<Ao$6y3eow08zIDjn-@b02SlDr2W>X
zsY!cq#Fsv3J8d{Vcp0wNFHVb!-Py~@tCsFMJ=H(@i&Osqsb)Xoq#yl5S~v2w<NB`*
zeJcyNie!30U|WDG{{Yh<C+g;V%l^FSQ>V(^f&Qx>>rd1@1Jp3=XbQ*=4T{6r=w9Sx
zFawN=4YY+0;G7ja)5p`{7McUp$*N|G+toUClwd4mxAj(<cdMhkZ*C}<XU;1nWu>H@
zra<h~?v-y6N+N|o#V$=IHtqHg)=m+mUfcfwmgjNFB<B^NjTNofN~hvGs%tXV?YKvi
zSBrZJX;L(}48x;ZVz$PPCQ18}Y|3k<*;MUpAG)j2ZG@M8=*#5rXdhPU2xV9yKPGN)
zYX1Pz@$7{#JX1%rE~DX(`!!l*JA&jIw~`3q3o7#7XiYyQ6>*BWNDIPOZffI+DN_%!
zWoQ+blUA0C$YKs^r$%*5!ovhsiqQ@-1wHU)aeIOywZd*<K3suB+eBDk4r(|fZ{$rF
zkL}>7=glK*zA;^$g17|GdexfWSxE~I<S|A$$<I{Ja0AT>8+O;hj`X+b-LceGTbss?
zHGRZpz2e7F(=`1)I1=GX#-T<HdAG&E{{Z<KLa3>OpZThuBd?3q<rq^|Yjy8c300x8
z2c9=pQJAxra!Ve~Mh-^Rq-HAEHDn;7b9H*z>L1IZaz;3&u>@wA2rHUF@&}rFGT5!k
zZXfYc6Y<X(t_QJEk^woQROCZ2;F_V<C%NTf$*mCzK_-NnIP=Pk(G^<c^Ic?L+bNZU
z5P7QmJL{<i{kUJFTmJx2TN$A$iZlII7gCCQLNgIieB!fY$6TYkqSiS*l46P8cljt3
z;VOHf3}CS96%wnge&OXvpsb_1w7Y4gY@?j6d{tXc#`8fHu$>r6aNYr+=d~-91Ymfh
zorJci(Vfzf%?Gwc$dKUEl{aA1S^%m+!ShbH5Tjwa&zdR-npXgWk2HVnZ5c2C$f&@t
zup4`HX5q#&TOUO0t)<-i6Ua;?<DV6sHkRl;$lHY(HCu6ZuMNQsuqvDy&6^U)shhOf
zUN)LOj?=XZIigt->LL&S04hChE!(N%Khdv+{{Z}_^&A&Z9loh5AY*}(R(9U7^<t5Y
zUO+#(!~UI>^mf*=2ilD+U3;p3-k8p#kigf-)_$$^drGP`X$U@ZTD>1x^=;0@O<l=v
zx?l9H%yq1R^k#ERxRd-OSI?Ior1fo`$$|9-+&}YAi`5>fXFl!oU<!-UbFM=5kURAt
znLSl1_^j*0?c}Ru;)uAK?*8qrXMOH_CZNB4iGaQ<(rK~0c+^?U$t}`t87t&=y>dq*
z?uSJMfNUtuO?PoG?%0*e=7+g$_-&hi6>BPCmkSAtD#vpD(61v;5ZJ0Vf99ASp9{zx
zQ3-A%k0jy0{ApStW2VezvoMs~f#R#?w_wZw<LJ@4M8wY9S8&HPcB=OO0JjAf5>m^d
zk&3=nSvPIQDyr)*DE|QPtG!gnUm$K3PdY0Qz~Zv8(W~?%@L0^Q#AKTH4H2W%En~?9
zV!mgA<c8%6vF^R!^tR#Vw?>hVT~~<z04LFWed|3xqH0y_qfdVX5I9w1ntV3UOu?N-
zML*O~7Yig`%ByYXc=(i&ULH3n@Xu8w+OokdS+4ge8)%E)ei%uFg8l_X9o%aULjr%g
zmd$<XH<zlVCw9h+c;v6LZDrqe!YBf*B73QawiJ)EOncvI;KbvP>W+r?6iyg!@G44I
z&e5A-*3rcT-%L+6X|gv$(RYsMEuu*bjgD$Xy^19EV<5lxRm+}5=J*1FTeEub%rd8{
zd+1i}a&C%+lO8CzB55S|3Ff7_X(1V7g~cCnuDA_b;gwc!`*%;D29CM5{mOiD2&(@8
za7Q_qK2(~yu(*y?%3z#Ow{}U|DebKq8Ov?vj-5%1GH@zMW>mY{!@7%6W|BNFLW`c}
zN^RRCo@I&+!G{8b)34&5Mh@yoJ!YV~wUYM5(Hx_6Dznmh9o>!0l3lrRyCXGX#TN$L
zxh;&;Z5r3OgbkSkJ}NI}BbPk=R&Ujk-$!{2mN1gJ`Bl!J?#pPcGi_oy6(x^s6tA+R
zypu;XZy`p&0+rylQ@Ipp?xHrRq_A*J18^<`zv6O7)mE3}dQYNFLQ*!A$!zsge(H9$
z*i-|GbWv<g>@wJ)n(ZEMYiI_VJn(|~;S9HkJaT^H2R#a1GS(Y1#UdP>^+m;J#{A~G
zMhK)4O~1g8x-*`khHH&Z8Dl#_pB1K#GTM5mA275NTl?%BbAwj#Nf?MGMnI!Hu1PPT
z%A*xU6|9p-a#Bya?Lq-5-;QX@nANA<)hwF?WVig(>Dm#_%INX!>|_4a+enhyR(R7H
z<kWFW8ua0EqO2|$dqkia`W0hsIwM>Ry1k4;ouC>X-r@;Vw7d$6I9hki%2h{-e2~E-
zdr82el1Paot|SutExDm%vy@4eKRPxWf7+=lLfgr3_hpDXe(96r;za(5E+mpDu_rjH
z8LpaX$Uu0jtx+U!4tV;gAhw5YNCB}{;&DpZTWqa$p6CSKw0SgJ!fow9a$ECIT>k)x
z@D4evP@-)(ZtoQGmC-p!&uSqa4(l(d28@z3_^o8|rt=XMN2(&D;0owzrA~_4vK<u}
z^CJ_uRg+46x5&w$^u_{04-|5$nK&F8IeC?`)ag-6A(kb1f|7o!+e(;AZX|VXJXcS(
zFfqZRZCzpm2nw2$nsMj~GP@d=rKb^uA%4vp?b;R&c9y6f;?>UF0Dh=<wP%<*IaMaJ
z(tm==3cbBB$B2}%{8W}#0pbQ_BR_RKOJ@u~xf%S^onn?epagy@r&Z8z!RFT`pUyu9
znGz6(aPd-1`(GO}PiB@(m~y|>ea?@P8BIkNJD1K#Gy{@UfxsPAp1BqQB;eI-VTu3%
z&)KZaQz6lXG5s|$;%51SoKv?L$ruFF1C?!~rl0|11=}nL6>FnAD=-7$Rc^8e<nc#X
z$g#|%u><O!4w(z+!ho&MG(@NhfDS>XNA1fG!@81W*%}Z|?;@`t`)PIq7IFEdLGErO
z;E$>lZDu{@x+3VsvP#k9fO@PS0{oLzaBKyHubQ^h8KjMmBOWS^*<E>DFygbxazTaS
zSqK2&(ktYhs!Gx{V{kw7PDuhj!PP235rU(SIq_Dy6uFSc(EQa~jm@|UFHJt&{Nxi&
z2gn(!DusDqc&5X#75M(DHXtGe9GW45A`XegTtV>2vO+_AO)?UM5CAQj<cu^q2a`>X
zFJZ%E=QKzSs;Br{aO$$m;z@8<7&WxGDLWNCp6e&7LSeaJqa4*!K^q|U<M#&##R#*^
z9Fp95sfYPvA)JhOru!fPlh4&wL#A|-1wqf6A#GjY4j-=+JZcc1H0GU^cI1v~5W3R?
z2$@?Tj*VN`J2IBsK0khIH)D3@WrStRconzMeKmD;BFQj#;yqNJXu>xpJRs!h2^?}<
z$bkj{?AEtL^triF?-EDiue5JZ+r_4n?E+WH9M+RUvl|y`;8!y?vQl*(5w9K;yDIeG
zNm#>z(UN~PXnixKxWn6q{{U*!+S|kc3=V%ZazPV+6&W4YH<E4g%TkK)V?X?n(g?w}
zPyYahhPd=LktgxC0R9Df3c(2&+e+5RKZv8cUtpwpMx*FGJi^f|dqJ$msrqjTi)>A|
z>b=JHD3y6kpX#e#D{c625BE`L$sU;N99rn`xIa&|D_I1P$-EB&j2@oU6&+`{ZoaG9
z(i>3NjIMsFbEhPWl8V{<R)}kIF8L{z2>3pCSX$O!ZfIN#)1^|gC=A<AiuX(JOxWB4
zUfDDKR%cQ4O}vtqKv(OE(+^OOQbli0{2p(03LsWi&S(qN-xmj(+G`$^yNmw-MKT3u
zuk0>hlVifbed4vlG%_w3RI$oEqZ@LJvl18|6dlZ}Vlk8ij?G+Zu`<ZwHBfx!sHa9T
zvbPQ5gDaw{?T{|iS{4YNNmT*M6TqqNLCy_D0Wr!Y4T3tVn8&L6E74NTXqT6Zv~W~c
zv*<Hh!>7j!FdGId#JvythHc?X9YAI^;aa^C%hXy#$QdUb{%eP-j%iDjb+peMW5Ycd
zY8J_8cE~e|#NO?nQE8u%o+)C~^!Ho|$NbROx}KSAH$3Wo#%m|DHu^OCk?O;cE<QY0
zPYiRyW1SVFJ?68sdc#dXL?<|`Z>#-veDE|@p9Sk8v}4g`ljx#(@yE7Oey3@+wz|0*
zem0ZH6_~VE0f|G!beGpREM9pT-1#)H%^_iq2b%O4G0G50vyqlcQf&ngWQlih6i|$%
z<pD_mc%nq=t`v`n?xVbx7>RWAS4gb{!E(|k^2Xjcrb+~v!NK!F>C=0%lmHCT&k>6`
z!Obs%4fnm9aSC9u`mF|mYLS#J{Fr2uRC;x{xpoOcaa!A0Olj^AF^+|0Ym**XwP>+{
zgm0ap&<e+T?_U=1yl6tP;0n}V-$7-iJb?U&^Ij+FZ9(-5=aGrPJW&%2H^}WWc`o%u
zd04T{datKhb}AFic@Bu-Z_}SO>t2_^#(OkkQR-3ZjlP_u<DRQWW=M<?_0?wVjtE?u
zzO*HPAn+>Wk2yEBg!@~VG)hC&&Yy76ph-p>^Huh&RE!QyTO>i$GmdGbQweVV!(x?4
z{#c?F)Tqg-#<M4tbDyeh)HA^WZRCMNg2?U;y1fhVkK||~ZX`J;0-@98LZzJLiK``L
zDfyz66y%eakTiMX1n%HbQBEaFg5#AS8WP@hhC-}+sOz$*<gN=<Cp5BScYM@p%1|&o
z8tFOY9MJ5#=?@L{)gx!Rj2e7-k@kupT#E@zF=NQ;m_RL%Gf~V6zTY(HWmE@tcT|65
zi&wRckN~9h^eAu(HsexUN^_Db6`U?rhC!*#6XUvwu24QnAQ4oW)KFYmG8n#C?yhdk
zWeX`LsjmwK=c-rAFN1NH2b{@v_BZWqai4EIRq9*Y-q`T}04#iYtmm%ECC>i<x~uf>
zs71BNx0*w+o(VNh-YoRkBPn81HMX|*ut~Ms0eYz>TgRMj85B%9jkUyK3C`}Cx=XaR
z#@7v+PKMiLvfMR|s1BgW!iTrG!jrq^XbJA*yt%;#V5<vwH>Tjf#-Lx)3WiPg(niCK
za%(5*d*svfxqZLn$GX3`zDQzdfnInfyyMpzlFur^83hM;pq0qchCgLIE&GRO;2I{)
z2J@LZHC1l=4<xVG=80Co!sjIOT4HN7mQyl+>9-{JTa6l7#0%}W$axj!_Og<yi{rZA
z`g%f^NwtY1?yiUvEhlFG0M(tc!|tJ37DQ$(kHt3OWx1P%01pO+xg-y5Mi1RtLj_p-
zL=wR6%`Nm%GPwgQw?FSu>7|`WToOB}FPWl%s;D{dH5ws_niqK;j|vS7G+ASV)g5_o
z&2+$kpmqfe<;sv_!uT|zkwD;(j=bl(ZR5C?Zg?G3_N5(Lf5fkvWa?Q%kT5zm2p6E4
zBe}p{4|%Iw;S0jw46v%rCQti-gP*fjckzUbvNm(wEm{gOx|^|gMd3|WDj@|)&MM<n
zgqC8T?^NO)yO=jMmTH*jWty~?$r<Z##e1ir5p7a1t)4lr3bl}=!P~HVuSWDPxbaT0
z$V+E{Yt8=vkZJN~!SV2Ry&p6&<f(Z*c-%<kn8rvHE#QjwBB;Ax?yPMUpG@~gIb79U
zv#61VK<2({6;1t~**jK%qSG%e<9Q`=$>OdwL}0%s=86-m!R)XFPnwk=wt~>Iu`S}4
zE>|T?DYiY*+jeFvx}!ExJmOf}0;;C6lHy-+r(_x9nm*FrMJj?~%jDH=G`lQc5_^c`
zBif2VpC+KU(hAGHWhMOcR)4jQI7wIeA2c0|R|epM$8LM1-qNHrY4c&LD%t_>bUQRI
zy>`uH(m)I3af)ZDEG4_N+LDzc{{S@o9@NKZkxX|GJkUxiJDdLiz_(nK+GVxuwrwQ*
zXQ5WQ5fPR_ki+h*ZWC?0dtd=T>52=N{{U8brj++Cg5=t^N2^=jO>iC))f1<Q8a<P8
z)Lr7rk#9lRq3oCiEXU+&YSjVH;te!SZ7$);lhqd!??6rkHtB#}(qglE=CUlA4p=UH
zQI081((EvMyEIcoU4SXYLv)KAN9B*jMW^bGb!@JxcH_KLTH@Z}@Fh}n%I2oYF3}ox
zRZQ2i&KBEt(cKoZO>Uc|Oqw=VNMj~3gZQZJS*}4c4nH)~nrf?p*xKct6t8z4SK<BC
zU-ab+TsB)ZEc;`OsvLa*L)fj_7H1@>JWyBK;1|WBcDj-d7<@$qd#LYqh#?Hz3U%Ca
zNjPR>w0NRLvO1#`86IhpjCo?(e2xDAHNB~9^fQXC(ym_eQe%EW<W-f@9gG>c#S5d_
zq!P2lIb-6QGK!0}$kf`fo4Jw|+abe!(^hq!4XMb*Nvhckl?C!KQP^9oQ4~;VRc*f_
zEwlw~Xzwc!a4LAe!zNE4eba8Y!7s$&O)PP}!w+oad8;Jb<V9?nYk@l95HH;bViEka
z@-$4)v`LR5t3uq#a0ovDXu)4ZK`7HSfnSuS>UWXB79(Gfq`aDBA!AI`DQ>%rvz(LS
zoh5d`(CZ6?xnJ{qPmI#uLLywL$TavZqh&H=VypFO$R6Bnll4Y1-7X0xfwru(;m=e`
zUMj!sSCRKsj|}EA>PTZp=&>&U0P>8#-D;Fljg{`c0q>U*d<S)$)&WVkF~F@(r<ms;
z4l6IN!uJZ}k($$`?O4CjUk$@FgW4JAoK?h9vZy3;RT@kmwvYmIR-hJ;=c8J(rF4c(
z`5N=9NH-BiD{o(h4;58?Y|6P)mOW7#bQei)lsRvsRZ0=tX@yONEs7b0rM`bu?|$T5
z2z|4+?xM0=)t`OB;13mJ`?x_Hh6t);+I0CWO8G=HSo_QjlH(o)O$>8e@VP5P%=61A
zFsa6Bd8U>qa=?>F_ccLux-iSRh<D*lOyOgQoaUe}C$uoR0;74Pk#_CCuedYhg*Li^
zQM;^mYMxLP08_fJuj6Kklz+WbM{Y8A91-HP&2md2Xplp{c3AkRp%Jry+!57HE;F=t
zDhCCeFkBiy6I{erQHIEBd>BbpUZWw{FT|1eL<K<}{N;y=oe;aTRwx+`D9Hq}r_1>P
zRoYzQOME7G3bR1PH@kSPE0Q7@wxXTq2BAl0eX*WCscw)fXOazdnh2ZRCxb+Sazu-a
zoK|{v_U2%C=Cxkd_9Std&g!r#-ea+vuOR^yxnkaWr3tWmg>ouqz?E7=%tPv%C(IVk
z6Tqs7L?zrnQGri+$zjhU%{DbuKOx<8s*#_N;Pp_3k58COZl#;XD5b{XgOT@CS}cG$
zM{JL(x<z65O1VnW31!_Ajg63Kr&e&RJH-l_m52&XI-`@}4?W_TAdeiI`sDU%vtNL1
z4yPnl%X^$0aps}aErj+=%ibwx${~wfm%#5eC~ukEIUQ8%3c(@gE%ia(N;i!0_f$7T
zJ2;T;>Yrx>+J)lVK!u%-1}eVpbp>{u)~EEI^4&d8AHTN;tkpB0(D6sAex81tMQ$Ry
zy-_5moF5hGmpVi+TOdfs6#YKtAKJyRfJhZ%smlu4$GH57u0B~gw`W5dQA&W)-)5B|
z3)hNgr{#1X<V~kM3bK$O^z@8d4tgf2^iO>p4dO$e6ta6pin}(pdt@NEqjn-N+tHvb
zB#fw8Mh+;L<UZ!mel$06$u@^Y8f?j4MKC5wIH#nCfI6brVTU*b)Alb#T#%!Z9)Oz0
z2avH|1zcT_Bfwvg>Vsz65fU#oT&u}sQ}9&7V{X?CEJv;?&c@x;5bcn9pzWA@Z2L-`
z)pKI;ylSM4)VS%5kun#D!q9iHZCr%OtKkx6p}MwGIXqReTooo{rnPww{+=iuLrAop
zJ-H%MPvW)GLl6Xp6f~B38QeMO(sH>&+I^ls>i+=K*zTfdvO8bA3h|#+=sL!gF%!Vy
zSEd8H`v};LxnYx3y2qyMwFuc}g<KKjR*ZU_k?)e3VvM>zEq(s!-lw0sa8b04nXh#9
zujwzi?Qy0Jr|P`FRrJ28rd%|0+qeV$SmL(h%Ng`$mN`VslwdL%uYEsrF;JV^BlAED
zX9a^PG;NxQSvK%V=Cnp7O`6+z<Pe7iix15*>5QN|GjrI@GS_fL3(BzOq@FfWgVkR^
zuxp5+!1kM*b5%N}yp3$n*d5iwqM+T?SKgz~3#iUN6&m0MXR=jI6KrD&Qbyno>LrVA
z^})$B*&;Cv?gXC{oe-DY2P&sOMueGMmJQIT%&i+_cTN)_jDk+%*`;iQwB{=|Ltxf|
z)T<xz4b9@R_QV^2RGj9udQz*M%s?WV1ZD1x3j5>Y0X@~TTQIl?jo)IbY-JG7xYf(M
z3rD=&fCXolXFDsoGY|Tgs0(!cq92!>SDDJ&vQ20`ZG6{yn-X(_S>NTF3!`obZGe{S
zQe}1UYt?-Ve2$3n^MPJgfQ|^Q$D|+p01n5B5h>O|N)~$NmnfD&js<A#hRhIhwTRGe
zM$n|-*2hnr1RJ>(d`~B+hS$k?YP<0Hz!hn1+t^3CsjcMW;&`hoGr0VFr!p=&Ey5Vc
z2fB2ziD6|Uu~0!F-SRmj?ub?-(lpHxXwQXPdD$O>;)zRvkL8*&^2IJPdT+X{{{W|4
zqZ~FxGG=_3+vs%nD}zjm(XK$0ouE_T(_FUsn<MIvz*zRL090u{3ge2C-Znpqh43lr
zMhGVYqZk#$fGSYQ(5y&2Qmm~XBf5=TWag2W0pD~$opOa|EZdDCa8G>HOvC^wj(Pml
zp=@;WXCb>CR3*YhS8hr3QA;KX$>xWiQhKRGQnzEJm5~lAi&45DwoWL^%c85cvi_jI
zjvIL;b^`*dlQ(JN@<}9P{cCc!H$K|8Rf)SsOOK9t^H#E4z3uZpatWbt!H#aSXr;mI
z@Z;G963a-}W`Z?|vnSW$wt7@j-XhN;AHdCdoDMzZAYkUbH`BLF@I)hU+zg7VBvDp)
z(zIXc_OP-MAP7OJFBE_2LoV8$IGRYaw+5pN37ZaZ!|tmy(=poRgT(~S(~@vadCk}b
z*p|x!=Djc1(=<A3%Do(pE6Su}H_V(GIL-L_7u+(q!u3SKC=zo*!IcF-<k7Y;q?zBx
z)m)1UC|E_dL{86jw9}qL1Z57;Ya18DM;RcB*y+ro)dDv{uYe0^0S-65NvUTLl_{Jz
zgG1XLz!Sp?lJQ8}A;4;|VYaZ#Zds7>IjFU1CwNICu~L~B$h(OI_e*}vEgdnt1G*$J
zq-|zq`96B5nVkG(86Q<7agrpHg1P7JxkN0PCk^?eVvG@?Y=z376tb*d-p3nC^<5&A
zizss0&2-a8JZeb!sOEr9^!ln@Z)V`0s@qdi+@oz;q|?+3kQ+VK{Dm4kAL0cNqcf>S
zsu-5|{nl!B8FHqzy22~K!3YakR*z#pITe;`k<cVz-F`j|Z$D0;S*9ELDtfF6A8JhJ
zjMl5tTBx?YLZ@gZxqhPw%LJ57nkhy(Q<3x~o!oF~f;SwIfkJ-CC039&(@^O0$EjLG
zHv`6Ky-WN6M2&()e3o(9k;V3X3k<FcX;ChwEJ;ZTAbG0`EmAqvPI&sL;?v=|Tuz|p
z&2`q6ux&QuAbnHGV``scUnRZBS?$6`Fvra@2rn(6E>N6#s35rZqhE95kGe1ZsEr@B
z$p_73X|5=;HqjNG%(KdU#w+-%2`}yJ<I9nnsghOSwgHzvR7`eoDObA7J9so4V!I1g
z!=bxN<@yz46cMZiiNVEJ+uB>kH^kV_ibT{RX^p8rDywa`M3edf)wL0AAdR2mYE2&Q
zCqEzMLtp7XySqtUzANII*2@jri1IP@R&9pf`7E_1NYl$9Hph<@S!SsrW@i2;sw4@2
zYn<_ps-6gLKYO_w;Kz|k6vR=BT%D?=%igOJL?gvE>qoZKqENs94P4yYv&Wys2^e@E
zk@2QkXBwa?d<hMw?Jd28#?UcYn=K|weQmB9Qe$JBR-vXzpKN*0nseHsrsw3-M>OMW
z>?v*Ki72*ccLF$|<C+pm#=y7YlJN_|(Z%PpRoZ@@*3uVQ31WPjk%Fslk}gX{v60){
zV~;qfukIcQ{y!o-RH5$V_z*z*rbv;-Gax06EmvbMT{E=#qMZl0xRdIpxn)k655+n-
zAy|FjKsc(o99+pDjkAH>6&=i3Rg$FXJl@e^iYeaS$wLqKstpRpXtfz7xMEj4RJ#1q
zM&sH>btjs)+D>~@A9sXl5_s-l+@~iLBxScS@la`Ci!mYs2^~~0-!j}XG7#DGRiy2t
zBgfAG-k`ZyV9N|*o9UamCWN{#6)v@F`-KKU!&7XcTQ~y3a4SW^SnJ4&;;5eH>@@z<
z3?DSv-BKV@gD^ARiJiDT)x43~q#4`^#VnL#R7J;NuumVfcdtKmIE}8@svH4Kn&JX>
zs{(V?O$Yc?xH!!ohHAMT`*Cj`#(bKrxwiiRFSrJ2Zr<kRZOBLhrb!$_iAP>)$fq7e
zX|QSJR8B<;9IUg3AI6)1aUSh}<mQp(R6sG7$3nEmF1isaVOQ=YP0LjGXc+>Y>e|}g
zVQkL-0L8hgtwBPgFg%KUFPcKhH25g)RNKlJ^_ns{H>#eqRacKB(%|G`i?xt|5csZy
z<MBg9h21#H<C8>L$s!Q`KB}fk@pHJ3h^tFe`<S;Q04ki2X%<FHrWW_A-^gO57ST+i
zLyCc6gf7<pMx1S~kdJM?HJ+D-GgOIguH&+Yj2d;7!d)OO#(Ww>YXd5o`D%3bZ|!E>
zVECnbD!h?Dvk!E~Xc6_~3J{jg-bQHHh-f!25A{%7M<5}y$*;JdBnG>MmIJ@fMza&X
zE(*z!`K?{cG_i;e3@bIOTbSnO#aEGe03wXJJ}8LPu?Q4r#YYk|HsCTTjM527-HcU4
z9(M;IwgUHxVUa!1SEEb>#_hSYx{*~`#?eNITj>)=8<ZWIx<vP4Boms>X+GNDD#^}k
zL+(hMmM)0uuY<UNh)TQmu-w9=oNpNkwM9c~pL^uEV^)rc)~%C=6y5>^()>aU40)<;
zWqy9)6>A)EoQHf7Q0j3j+u$zd1Byv2L^IGzLbAS3{?Sd5l~a??)lavbrFOE^O&_?x
zc_$S^Ajr2n4ab2}Fx}2F2UXV)`#>&p`J{$b7+*CA6K1id7?K|~q)+n1n@<E*ciE7q
zxK0$+)`2WrOfKB`H1KGF)`(J0SOR*fGUk1+$2?a>2>r%0$BH6oaUZyQ2CQ;OBbaYP
z89n)^VvXaCqdy>Nkh>WOCnAc1LAaB^`lM_$Wp!I-Tb;^)4<@N~OHx5A{`J4qEufqL
z7a6K++Y|?4N4b9LnJWz*c`7(;b3|$LNoR7CqY&zI#b|Hzoxrqd)lpAs$Vgy8%~2?Y
z9{2iR>qzwoVS?eZ>40-yov6(n$caOMM<bf~7eLfz(r;s)Hz9M#uW<B#s#8#Cq?GZ1
zJFI!Jc{O64@OrkPAv!O#P5|zO&~5gWcwCX@mOF^<><Xa=BCB+5MCtd&3xl-@;F`-c
z+u*(uq;4Si^5Z6pjzw$(@u2MIjzkWGGPjy3BL#sbsHVFtO)|m<&H$oeVh-OF2*6y9
z>G89I8#Q9!orTN^BaUjnQ;?U96@R)Yxn(Cj)MH>x?a37;n?#FAfe^_q$4)VkOwy&0
z>LfCdqOGHNrA^KTM-*kHyc@SFjGC=tcA6dJRMSK7Hsn-tr@I?-;*1flIO>@sSpFuo
z)tT(gz^V+ZD|CF(4zbLu6mN<u{{T)_ZNq}y(2-a=NEutM>oSa^#TRajxv++aA_Uw?
zsN{h}XB--wBQxanT_WYSk-@7u6N0*HJ?oAtmsIraj-eC9aRN4Y$rY<;vM@Up2|#`%
zb5S}2R(#L;k?3a8FAc;fe{9Dm1FFPN6aiP+8=E!tZ>@B=^&K`_c@Q#{JpEV9TGfyJ
zGgg`dz*ab}o{v8FvR#=o<E6O|(H)rkZZLdit|hf5JoXJx+g~D1n}7o~rD>PiM~wUk
z=DIwYim5EYI5|JvMR{oPC@8sHbBebK@33On6$RJ0jAK^FJ}8om72HfN7!En8p4nni
zBb<}sul1WI5{Ux$Rd*^Q1AjdAO3(@$utbFH;-QZLfpNjBOR%Tqw~sU=$_@l;RWO3Y
zN?c_}0M@rg3oKi|)N3e;V{?<qtv{w>l0q3yG2)k`CRtQ$(dp0!O_GMm=+PRq>kW~%
z4UvkMHxOBw#9tL1)_pZ7XT2r)=lIn}HCuLhzo-<AMpJ@0^Hq_lEyZd5aEjOFMT{tF
z&cdu1eN!W+joeV8HU_m`mE3=c!5!5KMhkQGR~jY4Lnr`Zg$8SKrf+oV86-(da1SE4
zIz`G%id6Albz;Qyat&W-mv3(4FY(PZB~0`B-8yT8dM&$rus9WGX3U(5qSNl8nl)uT
zRm3tb+y}s`uY=D@6(Zu<iTN?3BPWC6sq7^WCf)fJcA56T9Z+SE<aSOsV~T4ybC2U(
z@@+u5$f4$Nc^p!tSt(K+*ytbbp<{-?q%3$K(_HR3rYLUEhnM=Mx0*uyb5XkxKNQ7w
zjw~2s70<K)6zA@kTm``#)N)Lra0fqi0c*(VnBa3zv!5KAYq>Zlp-?=lzbn9^EBhaC
zR~aXo4oOsvpz}#9f=JC)Y7>ab0l(gr^gKCz1M0UzEP`vuzft`_WSjPIN%8*xRt;%?
zQ2j|Am7^j!GO)m}7rD5S;&+xtC79;3%2s-xO3~N*k}vd|#z_?Jt82&k2|EN<O43{q
zGtFu=axTz9$0x-!WOrH1w;%=Oy01X=b+LljG=v7mMOElto&<-RpQ_eDr|khiz{eCP
zD>3HEpT!2nb96={ITbXHi~*5w!?RIaD_Z{mjrh+-lT*Bo7zk`J$8|)Qn4tS+H}w}#
zg)F~npDdp>=J1|&ky?LP%loT_IpB3!WegvxvI>#93Xwcx{Jr-_#~hn>ul&_~Xj#ZS
z9~EO_&c|--ZSJf?6WYY#{!g0O`h7pf19SCQ{uQ&kIXza#M2xk%6gyAVXp0oKG8A<i
z1~XG%N~J-5g$UCGP_8oBrDgY60(kN&)yPLiOSb&wd{HuhwyZfh6%=v0kBZ?%PSfHR
zjh82FK$%2kifIs^i9Cvgg?45|ABuJTvoy@e-JYrfuWKTsK0&2m3c9uS1YkaQjGx5;
zaGM+|9(<ayx7#9>bMZYBP_zjSMBIk{CYH!IOb)W)fH|vd2+)J_4ONk<EQlk0*)?j=
z9je6eIW)*9tJR>yIUny?IRFwcek)<DINIA&3TrEHq2xL2R(yzLRZdn(fK|ed=>0Y@
z&ZaPO4;ZS;l2UAgR=%CMWV=E@E1s(!cGMjgVdhBoZ_>FYk(N0L!27MgsVvHEo;;ey
z`X=fKUN%qxZ>rns`jVe&BAHS-HS&K}cd2qn_uihGf<+ojA}HKQqwKF05C$Q?x>@~+
zt;kRV<BHCH(*17>20H=jvPLT+=YwlX`7~E4``Lp90Y{2^&2I|`OiB;ts_d@rMaQ;N
z81q)GYYfNToq%epQQGOU#Uz6)ziO@|+5=G+!aJ~{J_xF-duR9lEtK&@Up2%LW)#c#
zsvK>Hu7i>Vjy$xS<EjG2#}~~zWRiHG?Bu^PX6XsZtqqH+<1y5dc=!u#kB&XLFICq*
z+g^>NRfel@i*C#~;<1+6jFQ|ijY-;jrN@p^wugeWZf(hU_7E|O857#M#Q~#grf2q~
zToLA{zMo{_w{ua&#nDoOZi_pD6+OamF;sVV;n~&?mfq;^+#7`vpX27M7TsXFW<kL<
zBID#}!Nu}WSn8Lpt2{z7y!oq*S5lVF1eR~$d#e*=Zb+CQ_YcsZ^?N9;tr`h>HGce3
zlH!AH_B%|}ZLXpQA{ZX)t|M=BJYa!AdUH>YONG@zY@RB{^7<H)FaE<7RMb{VhbXbH
zjie#eeVDN#6a5NRfv-?VTWa@0$9n|FX&7I~sm;oJdtmt-a0M2ceG6P!G{}n=wjYWD
z*4x>fn8ydY9U;C;pLN)k&+)5hreAM!CJh&G>4{IVvV~EcVuicQ$ApX#=95sqh9o81
z0-L8^hlr6LR-%imp`xpj%E~Y-#~9+PFLuQ+a+x{f6zw}$j^^d<fW{6ejX{KJ4$yg{
zP9L~WlbDhgmH=6L6<h8qJ|FI`rDba%%YnsWwK?x4zf^??T=Ht{5Z_|1CCR5-WMmQp
zkbF?LQL#H0%`W*Z>_OgHhl-lcbeS`^<x924khg3D_HeH~Ju2JG8!W`H)e$@o?(hC0
zyZ0qXR$up~Q*WTM7nNg>F46r|I-J;t;Jnd~90+~aAfLJ(SBl}iv|vp#?!>Z&8+M*;
z#d#GZ(JXQXCj?cL@cz&cDz((yOSGI;wKpMqWy}m7!-J8E&)mkl*fGso!#sAVB4)@U
ztM65P&BLQhhlv7fZz#{|Fo7r`a0M`JI3vYPtUlGxiWU~$gY#WT+lpe{vGPQ+DO3Kc
zu+d;hp)s@KtC~?8s<jma!1<-gyKM~^rtGnj)pv&y6OO7;c`7iBE^}4sG`q*dl>4I6
z>ezq!!m`Q_&n3y03u@D#W;isiC$~%~&MLO!QMyFMyk&(Er`)vbi;s(aRc{=UuqVwJ
zsKCJs$^2Jbvyh++5l}}kN8`;$HO$+#mH3n0eZ`+8C3gzhQSu|YrqtqTB0Go5t_*_;
z0)j`H9`FDgE1klYQQ!t{HVC^HmZ9c}(=6vXq6}|ua?&su&2-;A(wq=_6+s9+$Rtpu
zPT^6=>R;jrr=oc)kLr*pFOodeAWokev-_K|x9+qS(r-TC-~s;tHJ>pth?F1!*sF~q
zP1b`WIIFR+1)b6ys^gyM_(F?zX2~LgLng*`UOWnt&CW{5ai0}p`U%rCEWn_{3W_+<
z<vY$Oi4rv=D*phzLPG5)jEV#)wFs3iq>PSy8m^r&jje(WT<a<B!WlEXc@;{?%AX^W
zYdn=Q9Q&Aj+mE^(7ZP`YQ#!D>Jz!Arg6sx(`=uaW`5i*56OQQnX%+=sXMF_~yolLG
z;}qw03EAJ~g@o8?@(G|)Pc(Fa8Y3GXF`CYLa&pbHcVBgIUu?yTf3;kdkulLIM^L<q
zmR+lcQG?_f=;Xt!qA`!EBu27=%rL$v&`2lWFh-99!KuV3VJg6G#WQli!7-3%yzESc
zQfXXxAwxa5g|K@jg}u_PCsIx~ek$itwpnBMmAM^?rDN{4H*6sF_f<F&%<b-pHskFs
z<?)JLCjS6Y(Jnz`Z)_UWyvqg-IUXsG`+JePR2c87u2_>AGNWhdA6`K$NgK!&zKN|>
z#-nMd!?-Zrj>UNR)2v)(5@LSA6keY--J=Cr-GKWwj(TT&7sof*>Dp(huJmcZXEH&a
ziLXfX@2hm3LL~xpNe^mIHQ)_*G@x(6%`l6UaQ4p8zt}ZX$1f<cN-w5;RRod9pvKC>
z`>AjReAA}-&(ykD0c3eV@M}k5`o*YQfG;faJdh}RME4p!x<Y->M^zJUd3=H9yx&ay
zW6>wTxmS(9s?zD-s6Ly$9}A!l<kCD$Wt7rMxH6)3_eDc7RtTq>t+dwko24Gj+$aA4
z+N&FR?8ywW#!uKZ7AA)GQDBoW82hKJq&5kt5#uKygHn7AHqkeuzi=JcAN160<6$(%
zhz2A#2f9^=9@?vMW2qtb;B6y4*D{URZa%6t8EkIFN@FfLJ#|BCV_Fd~2gqaUnBhsr
zIs2(FP8EeKro|?v*1+VETXPV2+#e#oUHxN$E&X2MP6uQP`b*Th?VgikEcX&B?Ni2U
z<sVq;@@rnDp6hPqVnWuPBp&-I%`c4=^Q1B=ynBNIR=OqUxW3fHkiAu8JHLrvknu)o
z@qus|hR?-zQHav4k>D!S?`yeL*BK+tM2Q;hJagnxGb3#bkH#u=!hr5<;%o-w)gGs&
z0{BG*YWTTsAB=gbeR|-mIEC=kl9EJjm6^R_)T~%V>%3JI=uvkm<an!lnXZ>1$sp5g
ztcBR!z^u+iPb#9S-ZOf^6-a+3w!WIMSi+`q<LZO9vxd>K$`s?VMA>R9X?7-FapHxx
zW6hs)q+EKY_x74mwk?i2^Im4+SlR9}SIEt2HLX=|FGRN^3-wjnys%wB1WEuORM3ii
zvg|NVlP9U(PjbWDIRb}=B!ER&-`ecP(VWw5ZCLY)G;2vEz_FohWK_}r0EyIv>Wh}&
zWC6U;ti%vW<IPG5snT^JC|Jnaz;#xsAce!ToF5g3TdkJ~BxkPcPZaUp+o=b~Kiwln
zY}nM1y7b<r71ksCPgSr7{@>i)!LKIJ?tqlUSngh{VQH$f+j~yr6{}+|4>PLMD9-5L
z=qebg&nC1)6&TH9JuP&GByHrH*dzOh7#|eO=cJUH8rTM)m6RM)q<y)eiw)T|5Ur2M
z#tnBnKNQ)R91t)mzULV6L{1YC@Hwt7yKzkolgP-Z-<+QUjSJUAQj?m7X*Uo$#Y)YV
zJZ6Bokc_BaXqC|ESgT;S6%(?PjQ3EpNZb&A6%#D%xZBs74UZTNyqHF(HHP)CsGzX7
zfARw+I2EtFw3<{PvFFWs@2fovbA2Pv9IVaY8m?`fEe<SCBKI95%5}T>^$V7oW+x|s
zRfCGt>VA>dEu|{f>_^@zn&(Wsw?E~9hCdaY_Bh-rD1+OA(g3}aUZv<Q1A45o{{SK~
zE6y~vRlkee7#q3GdtQY8+z^;>M$ttT>SoeO7g}wsam-?7`3|U?+14+K1QA^uTg-Qs
z*uZyH_cqhYt_+0dqe{$?NP^>0IV+vV#Zlf}&XLG&N!)*kqO9!YS(wa7DtOPDPf^<&
zn=<G=VwNkOO)&0^wfu2S31R$?HJOzdO^>5n80?$&gfQn7n$)5(%f~gUQKMP~EYY0t
zpA>eS=Y}hso@%;ZnHW7$)~f0OQfUzjNl*q35Q@-fQkDR*#w$9qyF<0fE#j^;mMAtJ
zN%L35@&iWuT|i;yx}1d(g&*@nLd-&;9z4;I5CPt!0<A<t&@+G)sV5AKec|!j;+{vh
z5M=K(`?>wgf06@%-5Uv!nqOk|n`tOd8KzwOQc1u4J~K_cW_hF@0sjDsjz5$@a@%{Q
zVvBL_%@GhG!0#0VMplJ=(pV4tQS8keK*Z#3;{t`8JW2rrCV>f~5wj<<rvtNBWCXSZ
zK5{t~pR<|7tF>^X@+$sxUuj$Tj8h?y4a*}&;I4DkWVL9$qFa$#`M?q3xUBxKj1_dq
z@l|9AnYzO$!sqi$w`T-0lBG=%bUmoa82+dz<z7KJ&1GXQ9iEx`f2!u<IHZ0?IVQcY
zOK7hmQmPvQzGd{Q%`TvVCL;#EjPz8(4LNuBx07Ex{{Se`M;z4Gli2z$qEg3SLh3OQ
zdIJ1HnmReHgdsRBLR{kR@c_?2Fu$aY#^3IOoHexg&Oxs%t*SfjHu)^zvW=uNZU7TQ
zYgV$z6>TKL4(ZEv7qji8pCd#F@do8=wJzyJ+ZieV)8W-)A!LzT`m4oBqlC1BcN7(r
z&W*X0@%W;Sq3>>uI38&-$;tFOv9=c`Nl0Y#=7`sY&+NBZ0J08h805CLPjXiS{phB<
zj^ZE?{7obHwInU3%KatgytFBBGUJA+PMZ~~Ga><>#T{<|jWZXX=v_+d+r&&qG#*F0
zf#SD52sFENX$t@W2B*KZGBI_}6cx4FM<(6CX0#S&IW3C<4n;?4*(BO!c8>!IK4*$9
z{wS2;aheh)BI(pNG1Wz?{@`t4{Aya01B<>%-sNqf$iY9FWK&0WgCJ&r)a<0Xv1W==
z8yr+VoVL2Qw<7I{=elK&<GRPV*W|W%l@x`?H3W948#I>+BpwA+YIoO3sw8QX5%X8E
zCi`Gr`68ZpoFb+6R~hz!g|)rQ5g1kesV(e(XSuun>xz2}SsI{cyP9yMpKg&i_F3BD
zoYyV;kT#OE%~Mekkc$!Ljs+U+1-xa591iGWvEDDk2AVB)(65k1vP;M^+@9#TVh})4
zR1PsxTSC^^T1J!^0-SSFQ*VXPYUM>{iKpzol4c(=b4F`ITmXRnYRU*!DMY)54L?vt
zlwlVpr?}@UktHP-R#-8T-)o$os*l<cOZ*of)lXq;@!c^!4;9yiRz_lY^H0;@u5z|T
zFhHBm2>PLI+=)x7VMPxO;yu|wNm@2ZqZm#GY1~@iDI|gQ8_S6f*i;$?ZY2j3A*&Kn
z-!2Z~YAD%m4q0(bno6iONFBpm4TO-Nbe5JNIcV6DJkd816<x86{{U3TQsyYwV{U2p
zI^bW)TdLf;0<3asw%AJ{X$d2aD#B}h*Ex`uspW+uhj0K^n94C!irZjzaET=XLQ7KW
zahTWwIHp^>i;&6=DD6OrP!+)=#Y?G-+epl6ur!@@Re&@O6pkxLFa=7U>XP_kO#N3w
z6zx+I)99|$E_Sy3e;S)eyb_Obl;Wh8DBS^N2Q*fikV3dIj8)Q{c2xo~l8|+c<ZmdC
zX9lb!v$fB-F`5F}drjpPLbXg0q?t;w+n#F#*F11v**TRGMMVP!iP-`lamW;;StuLX
zLw-$1aFI-yL%4n_izE6lFA}6f91-T3Gdn^uFu!!ik;o`P$m=yKK4B5E=Dz07l9Ago
z=W2|aOU6(N=bGYCCm7=&RNJ;$U*Z7bi|7SLsQ`Qu*y5^^H+I;7k}Bs_ibjk-`b7b0
zFSQ}U=CjFD2r|g%rXn*+BLv}_Y3`?Brb57QY8hK&Z5;9DlmZe8=OmF<-kqBgdt`8G
zjx*UcVWnLQdBGrZeACB<25LRcrIZ1R7-B~Sc;=jBX~yIj;+m0`;XxSguLxSNx&Q|S
zXnB==&zA>3^F%`!3NZLJ6qxt^YEC@RZ;}w-Op1m$qwI2PHK-vB0)vuyt!$9S$8kT<
zs_kCPn7zeO$AMJMabYuTuFJG%1G-pML~IIwy-O*Oji|d%=Aka$-owGFh&SAjWe}1D
zN)@DyO14|bsTEQ<a@gEzJ9z@hu}6PYKoK0WTS^$N8|t*SlSg$5?*3Trv$qNx2a?`s
zoib>I!9C1)?wSw4O&eSY)l?1_qxVM(sN}T;4jFkrnx=kODd*~p5&JuN1y6Nt5eGo2
zJU;PnkUdvO=srZ6g56zn?f(E1;+pc2Aq>1xY=rUzkbsZ09_oWzhugSUiMSorz$v?M
zG$qx)z8D@s>XF96RzY#@$(bAgDp{wDAZU(P%?&gH6e<YLY3`_zssav1c&dOt(npef
z{{Ru<jd@6X5uA5b)6569A;$xnk(`yrd1@prwA-ckM&`&JRjsx3a$Rf~Tvm42G)b4h
zC!<V%dMN{gjGpRw3AL1maCU+RifyXf`@~NYl|PCHO1pW2hwVii3g-lTvrV-OgZ}{N
z+FYx@+E70Ngc>fMCSe-755c10b_=wcbfu66;|7yr4UyYe{?z{f+s`7O{{UKuI@YPD
zovU`^Kg8ypZdK5*=OUn<*c=HC?DhDhc;oa-WyO!K^^0<=CBbU9hxJD4G8RN8yz5zk
z?WY@g6<E(HeZc1im)e8y8)vfr0Qu5lgZwA^qV0cEpewdS=Db1XkjOF!Um~ZDO|kB3
zu3Bg@mPU_sw*5h~cLz8bt2O;VvOoy{*UvIsNXQH)81AOD)Z~gm?h@1^q=E~|-)F!7
z0QteRDp(~}>Yl!NV=HdEN%LM_mkiOXj+&&mxD77S2sLNvqAvDJ>d9}lg6na1ST~II
zSy7;+vG*E4<aJlK?!s&h!#-$sR@@Y}LHny=jYV(<@3S!0;w!dtGHG3vpXiSjpt!Y(
zl!5?n2B<YF8Q}&*IRc%FMDc1HVb}&pH6q_hjI$r=s$xbUG2qmYl9K-blO%mq0Cd;y
zG1#M#Kxz?6=vhYdQeZW~EAbTTdHtiu$mW&BGB#5CvqGhBEsHPSI;Y#oY{M{1wEb4H
z)!?`UO%n6Q2&iQA)uGGdXnwIs@ckL5flH$|Jd(2i0Pg<)dI-s}^5V5m=~5#;#Ee_$
zny;VJ_v!IF8j<6YGfPb*WbZdz%Z2Kq{k+gHIV4u4{W*7xh|W($3O2{nWc=>3NbyRd
z%kimIQIof_lJScKJW)%gFhZqvky}{w^tDjY#gFV$Wr`^q41@iu)M<|klMQ(YTXH)h
zsbs<o4ngj{8eJmNK=^Nw9U95%nlzBiaJe6f3~MSFL+yZr4dl@lH*Ex~8#lnz5=O}7
z8Ftq!1>697^GQ}ltr}S5WRWhR@mJP&hUEmY@JI5jhL><v{{U|zXXw?WGmAO$gzRnz
zrB0d8)oJ%5(0wnegp@?b73kV+_V|DYAlHQ@>Z7cX9;?tjAFf3-0y$*b<E)yx617K|
z)@h{~Z-MB0m4;0~#4~UxNG?6Z7;MyxN`u`!7<bs|W=w7W098gL&jyBa-u6!mPYeO)
zswi35KyGQr10yvC;ClZ6YI3$g&vY0Q9FdYq@lO4$WplwMnjG;@-Z6@UDI|!Es)NGQ
zTH7D#qd`NAAMT_Z2*p8KWmDRd+VS^8$!dgQmb5JvR|kPY+}nb~0;gkqqGmN~INBa#
zU-+!--kXB-A9597e-*L5Ov|^hDj4G^NE}f1(V{x}!PTB|s(zeU+$nos@yIA^T{`~&
zMo|ozkr$?~QHnI&cY{M;+gr)Prs4Uj<%+sGSiMqGjZN8yw7ze1E`+UF#d8ZNWjHks
zy{CTAHN+#2BD40_lLy@v7-z4lp{hDq=W5Y?sDmQ=fwqy|EvL0}4j6Ifmrju`*KC8F
zas?!c)&%Yth}CTx<11EEYS!UoaS+1dv3kw0NeK;Gtwq()nDfnJb(o!<xH&bhFLVvC
zm7_YKbB@JW>HC-*KRBR3G0Z_9-A!$9sUZMkG>CG|cMuC6jagdE{{Xog4sqtHqLgjP
zJb9}PC9^Par)lo4h#EAujXSt$AA!|av+i}<&U>o6ToM3c7xPBKz&QZt6>=bRIsLvo
zebA3F8OI<Bd`-DZ9E|<aUE819HpAkY$YiglEpa18I0unZTT06jz}gs7Fp=Cce<mlI
zmg3=1EFlJb(l7{tll-9W0Mf{!K+;Iq`W4W>?UAy|;g3}X<L^)vNIq&1p2KU*nK;3#
z$xi2AmO$}Yn?_}s0pljM_OZfX%z%TA=%Anr;Ie>MfGU?%jJ#lX`K>Z6X&Z)4JXIdB
z4ZLMghRr1U7{+T6pd|sxs>D@Z>ho9w+sI#)Qbq}GYa8rjXniL%aOyGOV<x_V^zm7=
z<wargTKS^RMvCA%{{SJ@E7!kGwabaNLgBdMHRQj^bW+QY+>e9NdM2etTN%1-GJ9tZ
zlN@I>l3Pu1`vJ%1udbjoY2M&G;;C(?c=NxZ#eDf>m!8jMACzqZ$)!tZ1fKTpYU0*J
zSOH_us8V#4jmInbsjdp#D2m-c`=dEIRfzA&A=Rv+O`C>%@lo5&W=lz&W}r(eSO@vj
zl6=wj_O{Y(_<(|u>|GB@AXl+VvK`!o&jU4SXQum6g0f_I6zk|=XaYjOF#4%9^p#Kt
zY}HfCCa9FE>|fm~NG<X=pB0_;4ZZC8gex9ZH*#p({XRjh$8{X11F@R9i9-+=0)I5o
zlE&1RA-CYpUFqT!3P~(Sb#bCYBzBui6U9fZs8>^*<HcBM#bkhEiW8fX3w&}@I><F0
z#Nl(*TFW217yDE?ouLz?io+S^x$jI)s1TkhTvJMkDYrseZ9-#uo>HbW@!(VrRQ~{%
zBR^GDf2jzkRW2~c7^tG#3R}lLv7Tc4cn69h$&L(?Mg>i6a}iAK<H@O&V7Xo~wyc!f
z{*hXXi=u|vH3=Er@?*~wO5Xb^wn)f7bZzYG0_;{F(59kW%LeH-mi*LnQstt~QnrB_
zCcIuw6U|L;W?{jA<WfjJJ7UTHs%t?!DTkrCrNA!N0!p(o{P>_^j%lvFw1t?CjcIht
zCb|CrB;9xwp|jH>*f9_U`2xH84@h~Vzb^>nYCTC}dtu8w?(6q4NwLwF6=iE9rMC0W
z6|lU~P@j?lr^yvbs_CD#QmM+3#V@G(N3joc8{mB}sjTm2MaiCq>>H-%gF|aTyk!%%
z^Gue};JGX_$)gqnGG)H2i??G^M@~|UDfG=Z*iz;96HdF2E+k`;DA^cVWIrI&eUWmZ
zm#VeSSGj>S$3V8t0B7!nnp<^!ig~G|hiKR+acGGq=?63-mD?kcEu5aq7h#e4pzrl3
zc?w4#`_%JV&dZU)R4P(72vlVGHDos3v0Ab#X%WztA376IpJ_NeeNnoYj@m4)3m>Y_
zJX235a&T)#IH^6}1#}y4bcq=ua>k^N8JINrz;6{2TZoh#^eWQK2D2=FsLn}pfVn8{
zW5{RDDwgCH&P89!fXwPn1y^cT#S<d6;hN|bMLW0y1mcK-MPLA+ZeeKw3fMI5HaV5H
zvF5foryH_vc3eSa6Q6LLJxLU|QOoUYC43re2`Z3D6l&clA~LyZ$0<MTvWVYK{lkZn
zL!YeCcGmLSwo@g3sjF{sBL)X(qTAg>z&zCwn|xS!Nb{nM<dzty<5v%YPAT(D=mQ=F
zA(L^)>lODC<iv8s9gaBs(^fy0N$QD*YcNsCrMr({$80EB0Cf~CZom#PS@_t6U_b<U
ztz<sjibSJ4by=-y*saqTl&YSERgrQ)7m=gmJX6(u)XDCeB5jzHf+(v}ikM~Ho`9<C
z0I3@mE4Khs{{YjH2gLDH+!g}`O5?>2126>m@lwcWbX$WYJdERtuzzwm&e8m<JEmMU
zw4qpSR;@H{?xBVVtCXz~0o$yGZgY<!kBba&SAc2_vq!nW;)#Kybq6^(>W^Uszhr5E
z9~^yCIoNV{aZ<@_ceCf80)|#}cHK%sk5qzK<@Z+@J}SK(S-xxX`mG)HsgeTWvyT;>
zc-Y7@!Oc|TOoB)cetxTxR7MSq5mMZP8jN>}iI6?M^ZdT3Q3;kp>_|DyBq)K2&&V2V
z3dtVezuh$x4rNx`_%#s?KAkE_01SR&kA#;w&s~FAIBwZU!{F8Zg~66H^2Z(3(RP4b
zB)sAw$nJ%l%OsnC;*u+jHWZAG4H&MCZomu^O+y1I033me?8*jqfTyYrnUTtd-Jca<
zWUA}7X88E2U@NtIT-&UwIrEC9E~$VC$?r9(mnU>f%8Jfjz(X@I`Dco*NP`p*IOqGN
zh)B)J<L~N+f!awnIlvTY18&&(`!t{=GY@1$TXO?Mv3VnnfAK(Csw{{90Cf_{Dv--3
ze9&PnBDj*uWyl*(b$e+#P60!l)-qO=#^TvDW|62pq@g4`w{`fZi||V}YGjD~xy?vq
zmE-v+1MYyfpWbBz?gUX1JF5G6$UPc;qgYHAAGhK2wE3pJ-@4~-j<Z1A+_7~+Mg<LU
z^6vQY^k{A5HeAf>JO_I2Bh6E4O&ldmapIQN?qrdW{c%sZV>D#Q2lr9pK-^VNc7%l|
zZ`~tZZe4(6FF)N^-Nb#?0q_ChnQr$oO&oEq{&>fluV^f=dxL?JRZkVcr9>c%j|QOB
zBc3s~Sj=sl;EIpmmP80oH4-J47Fv|BmG>VgKhsy%myz5jxV&TPu=gt91G_(BtTap6
zA$3wRhM6K+tGtyQBLknYQpT}KA14PKP&g7W&&M=iWB?`!KXlc=Y!>z=+_-Kjb|wUD
zp|jme(QbUP_|&k%t(If_dZ|b@XEnV&paMuoM>rK)k0Lht6T027fx%L|V;t6BShHl5
zxH*h<j}(<ae3fq?&mDQEM5-NRQ_;;1(xkGidvHPI(Tvc8gkAus(4kX0%<5F^BkRps
zTU<yZM3K1gYdagV=0b6bBwdEL!EQe2Qwgxr$~Jyr{%fuyP{ow)HI&n}Pum=!J5L0f
z&_Q%1j5;_u^Gu>k5AH3h03x}SRX#y?8XO$H8T+W@1tiNp;o^?M3v(jL3q}-fs$1>$
zpfEslR=(_N#{&*(E4zPsBc4gAu>j1y!!+Rk01@VvU-HY0f<EakY}z@9DnZY5*&=B0
zaB)JA2hU|-$RnB|xw>kllhf1t%&;7x>aSxy=uqPr^F^zLBc0glt8he2$H}1T2-ryQ
ze(6#v;vU`1ZMb>GZXuikHw=T_A8Tu4ba5nV`0kbBzKHo;m^fh&#qJk4Kj}1OwbR8a
znA>R|n%7@wx@@=tGQU+>ap|biP0KG{DLuA~S@hfbFFil%m5w1D!6Ap5)miIsTmVFh
zf8M;bSx+3k+r)Nfx;Eb0Xj?Hz$|;nelY^<yZFaalGUDwIJHh_|dgv!s&f|*6*cJg=
zNeddag6TRZ6!B*>CMOnM2~O+-Q>3^|V<xFq<PnuMG*>L2<j6EiV-}fgvlRn9(uq}@
z8O2rp=*Ypz#Wq`#7?nJI)FhKgx%UFT+|<H#-~-K2CE)3eNG}r^Ug*#l;Lv{Xl?r@P
zJ<6&UV^j}%5CRxy%|mmkDL|y-K4?-TT%5Tqx1-3!^l3l^PCKfYZuuWD!jFpJHZVpg
zqNzo$!ef9xCc0Z<0bn?(qmnkp-stG!E}=mf^HGhBcru#3p8I#o<T9S?#H7?)OZ6nS
z(m%klz%}$Py9O=T{VC$UUG?n1`kH4>Hnn8Rsh+RV<-RT~^!o*nI^00#1ZJ(~Ke~ZL
zpdY-}Q_@$mTxjuZZd72_g?;aD<~TlSDB1fZL|1V}q(-Bk6-ldUQpk5N@&bw0^=P5m
zke$vCCZ@K&ig*!=k8|pz8(bQ(WNDsvsoKdM!Q3!vJ79{$IPt-)x2QDOFQRE7O|t(0
z_|`)1)Y_ks`F&NbQLuWj*|k6>t#pSgfyeb!aBc?!ocC6CgW8oO`!w+bH8%61Lacxs
zc&Tl9aNzC532E%)5_ad4nlQXlx~d#)tCIm@uCoOlW6evD@w{vGK)lJbYK}!Il19qH
zr#o_K(G2zSs$4eJ!{?JjO@-(AG4g5Gle<pQu)_n*HfN4UU8j-QpaM9!I0JF+pDor#
z(;p+vD<o+$vN#0zscuAN3K8=0`Jg~}ftunopFLK>Hq1#GUO?iqHc*tfQ_exHv_?PL
zDL4<diV7o}Ee^t?@mcRtAVpFE-T14fmwo|~t952mZH^g%rI1W!uOn>1P%4Bm-<)E!
zI;c{PN#>|94`(>6k{JZr+s`A9X&mS1SFZk@!~0kxXCEWpYccw5s%fyRrSwX8z$8}2
z4NAlJBlg8WCyMhPx0-W<#F5?fym5n5v(uuyNc8YukVQifvXUm=Kak>v(dCBf1VX^^
z)jv~JhY1?(!LORQR!V2IgZR=jdb8d^b?w`sG3UCp(r)Eh6$*U3njt;6#`YPhEn#Q5
zCNL{RrxzNaHt&+c;TG{#9Bn^zmlhJkZ-{0j(D!rPTer5c7HUW@FBAU&QW9$}*;fUT
zY?ja7h-P8e-A5*>>vQd{Ks{ooLp|FP(G*|*02-ds8&N;D@pJj5sHgHC{EfDd%Hf~+
zQEwul$!(_<4zUrowt214mIELPrqOPv)D-*5L+2Q)H2PU;9YC)pSmTSEd?9DN{l)7;
z8Fz8`s|_~vq=E-htUDEdqUi9Vd#a#0@<l&T(xP14D&@z}uSGvVOBWB5n7vs_bk_wg
zw{f)*hgqjuvQ2JC0Jb<aCZh^XXiG0tE{(JyMK$H#Hy-;(T}mz-6&51wY7?cy5QO|`
z^XRE@c9MI9;O4Gw?SXB>gGn4RAPn78`|j;<OGFdf1c1W4WMec2nQuL_GCa)5o+{MK
z1dp&c%grqDh|??n^r~;KuzuCZJ<sh_Z*P_b2#U8Ln41IpsU?WccK-mU%`8@EgJe&G
zMN(XaGFxH$RmmZ$Nbbb<Dur+f=AnB@5pg5u@lpH2Csf(^%~^&}jzuP{uOuAe(tMkZ
zKiXAA1#3xXuwh0B#bET7j!3v;xK@ixx_BEh6SUXRFwIXIl1Gut4YFvxz1q-~6`A!T
z1-4Q@kgXKgR^~0<-~$zv^*pi90TD<zJ}SLxjIc>Rpy^v#qGqm8IoxrI=Zq{H)x1<1
zfR$m~pqhhCmPyr?LyUN@0Fy_q*qm<6_P23&B&8xkMrzAPX`;9P04XDin(YKK`+-Gq
zkz_zX0<=nMQAr{vN`aQ*R=PXajPPiisO5DG!kH>%K~Yg$-N>-*@+n=ms49iHypbUh
z;-ExEJLEa@Lo9|)W$L;{GAT&7{MFlN1ebdxO@L**Q1<Z%xN(C{wYIp1K>PQBP1G*c
zNoE){%jt3}Tms(`T&kW86{op^*vBh()l&ZLr?|?gAbFy#*{){_PBzwwV|!_WHPa=$
z0I=|LRr;>)ZyBo_#n~c;{{Wf;R@wmB%|0H`uZCyt0aKCPEDXcsP7N~m+}*(9p|+FU
zJe*fbt|Z*7H8m6Oi12^9xwkN!NLX&Fm_2|(kO?$=Hch-fNJ`C>L;4vuPd2R4N+O9%
z8amS9r%b;Fhe2#52&fBv(Q-i?N+b`8%Po~j4_;a44*vXLrz6ct0N6I;HBF>k7~I0I
zk>al5m@95{1d97|cggZ%SmP?$=v0%sg;K-g_ed@xkxTWD6gx}q9hl1apxuyj`%Nb3
zdHWSjtShve@Nl(nXcjq0=>1aPLmZJ4oD<y%a)4vQmnBFhv_6HfTg_k>QL;7MLv>Xb
z$hOkqNBh*eZRGas(!(iCj2wBYTHuWZdYW~gTAaj)sHYemRYa}1hSC7@Q%sW0BTA?F
zcloHAEvtYzG_h2uE!oV>?7VyhXtb-qZNypm54xm|C-(E!JX5V@_T?T%d8doy2DN0&
zKjp{!P>(5A{{R>Qk{MD!s)V+F>3y8YK|J`YNp?IJW4k>4P}7Mce6YwgWvXssWZ;gg
zr;st*v=BVh?SxBY*t~$ij;f1PfJJa+Md0=-{u0~vqVPv_1=;rIJD1!aR3@y3YFLRS
z+dF=!aO@i&>8njbSmu;~J-l=%6+li;VD(g@5_^g5?If;xp-hK<)72Ms5Oh-527`3T
z+M=NcC~THqe-(40+z<UX;MF`}rUr0Fbu=?=op$mMW|}UT4MQT1k0f_f+PtcPSbR^K
zhfen9K;^m}Q3mLHp-N#F@mGZeIEmv6wN;0jh6LV74h9V~`OIYKcofLnY~)~oXrw~L
zQ9|!yRa&$QDi==09OwK*DJK+`fg}vA-3G6M8JG|&64=kxcG+-VGsx^wx~;FZBS^ha
zt19~eS0TUDYKEF2)~~qWe=>QarNnqFepu?OVJNZ!jB`Xh<Vn4NJXE3%-6ObT@k)_e
z6y%)JT0Bz742^|7ib=hrGYIe$bwGvwgM6$uw~ngq*=3LUbK@0>)8|-a!9Dj{i#ej6
z5MpDxu8XupOC({ODb7dLB!Hje<H4!I2%`5Hv!6a`U__HAcgmeI5C!)E!r_48y44y-
zFc5j{(F*FJ!5w+1;G1p0!2bYxY9UpvSuL<GIbl^$%PpL#a~TDc<O<YkF?-S-{{X~_
z%xX|c9DrjH=Bttm4%IzDajHPE+}p;iI%OQtDHtJT&H%27;t8|>PAVyyO@Tld6<Ug1
zAYJwoI7p)Ra!!02MxHE2@Z>P({pfjL{@fD8pCHq1!xSxyDd^EihOb4`KXkw3AUajd
zA<Tu4Dai9!iz$)@8;%^FMQgO{gk@8_=M`e*63Yi<+p{A+Xjx>DKaMd?Xz*S{IVAa~
z60ASSYEW!?$sy%bGUJ?3^8}VR4nNwYvyh`QDfoG&xrjR#ZVyywmSgoRaTVDo<DRH(
z?89z&A60*@+6m$J20lJ&k{{bGo5oxGxz1|0zy=vNN9|`E`L2?0Z45wXj_7PL0Z8-w
zsz;Au3Li9R7BQr9p4j58bQ{wSA({9+Rb-nLG8->TZmTP(X4=cnYA0Nf+{rsUDph*(
zOpaDo+WvXws<dnKH~qUDk;ZDqTo(#XaaJTiiKFEt;|7S&_(nkd8fCnS@cT@o@M(!0
zfr_*6JWyyPH<teD06@=*qP>l+=EIQ3>a^i^{7A+*%?+yA#d8RjH38SZ%_NZw+e$OI
zkLU`L(oMj$yaCk@aG^=T!w(cOl13XcMtY$_mZtPC!~j9_QrO+JGVelps)CHL6=BHp
zU2fBu%c;ta=ur*47hk+ZWZSuW6ksasH?JeQ#%TAflM@*u>{f!)QDUV?1ez%mu-Q}G
z$lAOfsnEq3U>Qa#7@vD?EzJ=esLVF6BfQbrD~<L|BoUMw1_f7LF}7mQoxUo<@z?})
z_^I(i>PYu6h_;GfY^Hi_bN$E`4M|+>1cCQbwf1;d<NK;h$fdV!m^q<AxK{rF<Mm6h
z%|A}VF9wb+P2+sz5%o=<Rd#X}SZ1krIt6DP^+m+YN4dcQk-*O{OM~GsnY9^WJci8$
zaq2aPD(|$_ntMh#<e5QM;-7b;=(k+7O3XzHmw-poaib@3>u4gA25kQTy$5ycYio&>
zBangTn$b<@Z4PsiyGg2xuhUyC<V7(A^+_nq(+^I;713#?Ys%1rzbjVO+TP4DZ;fSb
zeGh+TrBdXu@H11tr}dPN3zh<+a$XD>{UJ&GO|`$NA&+ZhaaP)YtE@|IX_0>!uOZan
z)$H<;!f}qpQ<c4!I4+E8Jdfzky&7M1dsnQzWv5%|Qo78A*+>8y`M+3{US3N#W!RBd
z7g|Q8cG#9@AapZM(|tX21?n`hmq321naguKIvp%@k$l@`%k<94&Y8ARw~jMfJ#owy
z20g<)3{vT74X&E4jerjooY(FyFXkfLkc-tPLvuM9tzd+@3XDlSnq4~SqMdh>wu%~T
z&c&o3FS;TfF%^K6fmXtCM#xlAe_~cxcPSV&7pgQk?ybGp2oeF4P^bNy4`yBI^`5HU
z(&Z-k9Cg)S#F27#dC868o7*Q3^-@67vxwAZ2DKie(OTh6?WABb_6M5G#PY<zxY*gj
zq)Ld*6bEE+iBywE2tXl$+nz-OZdt8_u5*FK8>dKa2FZyWaB9`i0--7sj#`YhR{@zu
zJ~dytpc^Ay-1cadd4zdpz{OaIW-icw)MREpY9Sdn8;Bu1nx6VR+_Z{88Rn$izRuI+
zbSN+ZU8vo;8?LC$K4x4@;az~n4GTLBn*@B1H43{#xd*Ql8X<3K8EfT{l;E7!mG-*)
zIKZrZo$Iuyp~&X8Q6d|3Y~_gNj6#8-h#@2{<~>z*sT6^jY}=7njQ+_|sv8wgtvvTA
z&JGvoP>@Vkra)&##&cAK;|$6cudkq!EY7`EEck4yC<J#|CW3^C*$CL!2DBP&)R~M#
z$9Oe!`dR6H57dnIxA)$~(HKGYYeT7ind=^%x-&%&?k&OLhdft1QI-_rT$}Xxrka<7
zWBPpZ7*(V>d<xcUw#WAAAQ^Mwvc8P}01!~hRQU(RX)Z3VB)Isl=+sxrJwZQxp7Tcj
zDvBxANE>sj1*0uB2%{*-<0gr_oiCth3}ITctD@aoJIc<*4_}HAikhi9WzI_ZHa6vD
zjioKQvBd>#cm8HcGr_2|UCS5@<k6e0424eJ-`!-CQgl3J#TFLV(37z+T9@J^-rxdi
zrC|}w(#GIa?9*JX&`2M2n-%aE_$|%E424Myan)Dpu`m5YD1Z#m)|Rux>{W}^_KPK)
zR&KW=Y{I*~g9xnBc5^*a)-;i%)50PGO4Qe3B#7WIRR*4r$!?M%$TU^lAVAD80IyrQ
zqk?3wS7Wjfl{H(ZL+o5R@W+a`)MkSiL%H+KP~F^^=L8&c)p(CqQCf$$$?5$)N?28v
zdW^Bd54hb5tT)X(M8pm%SxCHy`55Yq&~zE(Lg~tVRvkVGXL}&6nkP8nj_I=}1X_%m
znPwXkHD{~b%WYyGvOHGA`hG&a3L59q(@eWa3@f1hGgE2%W_Rj1W!#MZoU%`5vVn|`
zG@itfNF*68^;#%>J$npZ+H@+<)Bc~3T?uaxFz^j5JttE+(~Twx`i>Yz)U3x`J>y`0
z-OhaCrduMBi6&2x`|)0*Ev=kO%n8Thsx?7o(UtZA&2-=R{{SBum=~;H@iLkOMOnyP
zf@@o+EHa=+10(LLV^IR_NWz0e!8uMsoY!|vhFGyEN!v#&K2<rnAl+up87$s7LkGtM
zRuVfqyGw=_4#qt8Yjkg2hR~y`s??!-vSTsvRO_@~s)b!L-6pTtmnzdJE(C6bDF=$I
ziq~z<P?7kp6X_2OCDSdA#ZhWb_Kq2sZclaO^&Xw5)2ou;?&<Y-^E!hD)nE$=E^&&W
zmhloqj1oaS;<U1rzJRY|6;BO>B4QZ^bHS|G<r?JHlZ)gq%?jCqFa|u;dmxkNxDiv{
zKs~b=>YJyeF(FBM@M<QKv>(Vidu=DS$}#s#c(KJ15dojYKI%(#V~#$kP#B%#m8&Cf
zmQE~nv7A6b;;LtXq@9({b4T4>vJ3&A>YZ+pO$m^kH`QAf<H)iBdq|*&1RVJ^%{-)c
zTn<e>{$Qg7^-$YO5-E_LYUG@if)DIBQBCcds=AMIVD>7)DVpLk_&5~{qA)CesN-%f
zglU=Uq{5JDtsy(e>nFun>JopEw)2V(JpTY9d9I!|)I+s0NNt%U4p^L3q&F85xP^a>
zQzgWragmg(Yg@<$2=0?AepQT%drJ+cdoe6&_tyU8J2#P4-@U(f#8G8F>d#M@%DZj`
z4Pl&RACnzB;PF@#M&d<o1!(MLj^Z#$=NPIRa<IyzfXX~m*5Iwtk~6h)(66+{RD7O|
zB#06$W4h#0P+(wv(AJk<xKZ*L`l9~;aDRYNv{Ts#f{3Kt**U4DC~#PDQM+$oqyhP<
zC&*2s9QmPSE44dxoe5RP6-YhE^9qc8)~00(XV&cbsvFx@4elI(eA3BL0hAc=&gJ^1
zF_KT>Jkp>lPFwzKkiK~1G=L>o=SYl>4&H?#ZDag)znYfrdCj_`U?`vi$-j3e`k)g-
zqR6iMSd5Ppb;~+UmEela+e#snI3zV_EoF{q!^qhLWYy7jh>4s^%CeJyX_2-hB%Z(X
zOK&f__)tm?g(Rp{KIQz1BoQWZ=VuixYwi<}58Ve7KFz>?bak@?P~ZEhlCl&U)w+pG
zsKFj;p&M%w$NDv})U2bLBeb2(SzD-#QW&<AwyKn9fWe){Njq~+j!X@{KI@Bv2~eZ~
zQ2<EDq+}9Ii4HPz=A?nuTjV;fjDQau{%SCUxd8J(h31ibzUrnhD*oa@v;<G(ScqJ}
z;FHKTtkZ5q%u(cx-fHN(Q~<=lP_4^-Q<O+$4S+zVOBCMW3Ny!b&>2+YvMR;MLs*#@
z5I_g9ifV`fJ5+=BT>~;U_W%Rpog+uj0ZHnC23^_4)}^21SXNqi<$>9DaC+jkkTZV<
zIT`aqdV&;{3qpr*6q7_Ui#{a4Tpy}XvKKDOaa=!%R$rETqhOh#w=u}7%6y*cvI0gk
zD(4|6>20Gyz48I-ql=l<g8Y7}TcYyd5&-B5gdhsA{{WRve-(e}i;|JHKq0!SDJ{}8
z4DXZmQ$W(fM39^+_@<1gh}pv=dye?Y-O#Bm<0&>z0QjISF1_nznOBfGqaeB88840A
zD(*WWEzZall&0<78dxEWz!^u(_^1Q>(SYX+4NDp^k8-#hXpm*_Z*OTEaptM@)ic?u
zDCK*rw%;hrV?HVit4UdLv;{rXt_Wg@c$*mUObsA81d~Q;mhxL&nDLN$CWC3p%CWNG
z{nbDvZ+>@GVYPnio7{=Lw``9Xr!;J(NRuPFdJM5HGx;?U20mOXw**!GgLcw@iZiyV
zrC3%JJA-GjMd>rg4eFEyRPjv~Lrrk<6$rT%#2kP@KXoKhfTi)cRB*`6C}23N0!eRy
zG2;u0is6&o#(SbJk+%sKh4KYg-8T0d2VQCrBwB+JSL6}JW3?-Fg5}g639W=uo)?y3
zRUV<YSz|JyVf@gLOw95=7C6pUn-hRQFVC86XxrN?1`a5L3PhpX1Rkjc5>X$#83Egh
zR*p9S#>BDkDY7<3Bc-=20m9(@)MO9SLt4wvpEah0M=FK~1di()A)I{1aaw%>;chKL
z5;uxyvKAIc+mxiOf#A`Fk%1ufRW}TM;HUjGTm;GS{yC-zDoD>SCjbhQ+K>X_z9+hD
zQ4ud-flr;-#!^0o217gQ3uIrMe3RZPpsQ{~+yL&i7ZH|;flU5tg711cKF}OvkyW)s
zpnI9zw$MQXx`0aRHbxIL@$e%fC8?^LToT;orJzwYzUbet>{XthDHlQae158^N(|U1
z28c;MKm&?|qgifO-2|Ki&M4`^gxotnRZC+$b3~;{IO8>P3N^4?<e&Mc2<W9UT9tLm
zuSS*_WifA1NfivQEK#gL3>q%VR*W6Z@WltwD#V)EE}_h-0}hR5FTjdsQ^2iclBfZc
z;ZNOXJwdumNT>)M;*qOlXaOWvz-~XfdXj{WaNSjJy%SG@#BquyOO<W078{2~mW86q
zNs>51mfU;~s!MCXYGCdO6ai!qmU2V*t}+{h3Zs=CDkK^<I(&<D5Slz;dlXAyj`v^a
zRzpP8E+Cx8{8XPcp?O(`?fiE}tTYiL?SF!i{hFBHp|<_GO|E)s76ogcinz!f(nhI<
zicga-MyAxsLvCY^b=fcvo+~G;+M8Ry;1)mXwGs(cNyyva)n1~Xyolt6E8QKbgK14^
zEDFbRaD3D5Zk<#J5IE1(19R}0D8T$0oKNkbRmN(WVoXPhFSDf8?_*zW?VA)ayPb|!
z0uSI+@?JS`7zU%PZ(&dsq6GcotM-1y{XBdyJ5hHr7=?%XQF3Tk7m_aKC@Vpy+``fA
zL_mJcOzk0T3=`mr3lc4cB#I``64T;x{{Zh@b!~2_rWnc|jb1ytI9Uh#nyu8L4&~Lc
zj{>Ywu8Tn;xodI|@(*CvbJiMSl{dEE#PUF^$#%C7#wk^Vw$fU%1`IefvLTeTzB5^@
zYB9896=|ltuA!KGQ@YQyHMQ)pI)%evRh5jgY$_P-J<)>|m$8#^$RH1@CP>2D66ZWs
zY!Z8GkZ6H&^CKxzNExe<3JZ`u=h*z`_}42mP8%KgG%U{RcG3Vdo<$IGaUj^+Nc*8+
zI(eU!P%>&LS9*}glTt#(CjS5^2L}|lD4U&-93F`AQos?U{?qp=vZo-{t{s7a1mhf5
zD#)R^UBrXpw$QRH5rVvd-4rr9>M5g(dCtb6FXf40P@H|!ueBHAHvT_V453cPBmJs0
z5{FVTvalQ)$ls_(_>4Art){UYQpifFPzN=N)ZB^K5#LppAVM@tsq8OeyM{(aMh76*
z*B_-muG4)>pha%w9&}Ky80R(d%uL(1lYxrA^slJzv<s0njLf(^fP1cPt4;2!U7Ix8
zk8RWF`qx?XqJHSy*Z{stimw(^Lj;@SDo5gm{WASPhh4CWIa~br!wlD<qFdY{_YfS9
zs`48D07}QGmA)i;JvOpf*BqnBguc}7-JH?sckjdP$e;sPn*RW!-dW_iwQZpDio|M-
zb*9Q<o;Ls<>(A;vJ1!^6J6QD?^M2RKrng%=Yhw7xBZ{W|f?QoR!cv((bTy`=B?__w
zkE*&5rNy`rd`arCNlP2#(-lHKnIj^ExX7!U8$e@7_X2t%g3>JRV<l%`SN%1Arot^5
zUQwOLjMrb%{W)qs+{wyb4t~E_@%$m#BG@gtk7^QIx=n9I*n(9ZjMc=~5wx+#8iMWB
zSxp{o!ps54uSt(hiyQdGBa1BAC;OR`^u5uFV{I#O<29qycF72eGD#zxP(So&{oimM
zqdCo41xs5}$O%1U)s8Qsw#@80CRx}5am`Tb+F@sADnVNGJ8}LTE;8NJH`;Q04TKEL
zJFb4G(=g^%l{0n^P|1b!$}rj-N)y{F$>O&feYm!?R6~sOSg_OS`k6<J?FWO7D$?WB
zVh2s=#2z@Veuo}C4oQ2?pO5I*tCaO|Pai1Mh+Br;kZMsI;IKRoHC3l-w)fG0h4#16
zs|ckn5s!8W9M^vyNMw%aJ4YgT<p)wg^Xhhp#xXjH7qLZYm%`v~QW-~)UTf-0TdQwS
zw4}I+y!fl%OW*$9e`vl{zctT}y}eJc(XM(luzRW5vDBvv7sjcJ?>{Pi+|4Ao&lTGT
z3^}f;&#EJ6#_X`*RN06}g-RkwgF(Hp2%#<Kjid;A%|K8^tT7Xo9GWq0#|LO5?w_(K
z?YD9M)f!6e9s&NTSiO<8y8i%?NEjok%X*_jX>A$%0OqvlE<Mfd%AP7Mf8%2O{{W||
zuPRf6i!H+^38_c3%WWt9yr$ih=b=(xMpZr0UHtVOrAF-VX?4aiKtLln>bwk~y~;<f
zoZE_EDKGB63yswKh(u|EIjSuxTgAL=p$boRX?=Mj0mkgpylqO5&C=is>NIIEPZXvp
z%I!mh`=@&o%A3IBx|OGB?fswzY4><QqP_OQ_-=DkU5L`#bZ4A+r^RLapk#Ic4;2;2
zNb?vu08^%$BYq6)rNzYL5_Z(40~07cRgy*`%khIi-myOw?zOCq@Pv;nxQL=y-~pUf
zSobB~ql%u|LT$o6b5Xze+j9Q^y;T*pjNdd-U0Sl1EGnK!Rb(i~6{yr*a9Xpo#|ybE
zE2V;Vxf0vxWwpd+Q651Ct}QI!4esP-sv?FQ@BlPboL2_qDSz?P<mabDFUffw@}r1X
zAMr;`G)o9<b5Pn^+pZXZT8Nq`%HWPGn>QOC&l!mVMV85L6%j0_B{7;h;Ur0bkvXMw
zMo;p8#eJChOF&S_@yH%F#b~VLX<`gOJXI6Iq>pJ1Xx%nx5&fnHnk{q!+AyL|mm-P6
z5%OQ^p~D3QMnR*DW#CSUA5~!pkrAR~3MfmfK_#;xIHKZ=B)=xd;+Y|1D*y-vg#^r8
z+N3|pvPV@OM1&By#b0U`EMg^jHBga-<962k)lYx}POl*fP8N|ZaHajsW1;s(xkhzY
z9R1W1k|a3(B7p(!6v)BUV*?a^nKR%;w=@*lR0BPlmeN*&;TcAA*{6>T28I~@wB8$O
z`lNZXa>pm?rMD{SmLP&Z;-i)Z-WhortE-X`Ay!sZI5j*0nKrQIho5>$v)UjNM6OYj
z0OZkB8zOn6LQrxC{wk{e2}2u&UEu!!Dz}|CO_d`*ROsQ%PaK1TLQ%9s8txR8W$vPl
zSh3s18>v7bxNyh%p~tw%{xz)R2AH<&3VpmXHXo{cqannDnwm0JJ)^pSASylIpH*RD
za3GKj;d4Pv9H0i;araY{2@)}2N%2gb1lU0&j~Hm%Dn$_pjDL~1$Np-IMY@rQw^M`p
ztCWq*yAL0Aa&|&nfFv0M0;7&S?4n+Q;L?^~ag~m7^++ZGK1xmx6$lrYcVLdZ(n_ol
zvv8Ei$GI2_%Xdz1ahnnxsO(U%lvmb1+>Gj=hU8UTfSGoj@x^H`m025MJBLE4=C_cL
z%rM_oOH=|BigY>8^eLX<XV}Vj4>dZ?AxsoMA2f~b2UZc~k3ymV)++pCkxFJELUc!e
znv#2Y1BY%8WPMX*Rd-Uj&)qQ#EhABATtw(Lnz@vNwWAw;@mV<cqveiBJXWVpMwZ<q
z9Gr40*fc_XNi<7^+xenx5!Fd6yTvs@3L6Atu|@*s-z$uHrU)!xw2TX5AI6B8CorjI
z$NvD%p<D?79Oj*J&y+j5JyfC;exkOK;@$@%&1TnOC*9<Zt95?^%O3DX)7@h=NKzYy
z+s`zTRLIDLzabc2D5hp8HzpKtC|Feg0J)=CS>p&fG^_(IB8^lspO@7rV~hsNeb*hM
zayY>sbUZ90k(eHTH4zPOr)GPra~mI$_@kn2l9a_}JwI_QcR$Mkk9Dgt6~i7+b#i15
zP#kUiRd|XsE5us_nj$80!bRwJP+c$*8CSgZP$Iz-LQ8D~{m{CGSe?s-G;oyc1(fY>
zskcfdg9nUMA%(t*IOdR%j(DiZFKifc2a2@UY*b1l4S;;rQ?Q0L0O#(jWFZVuut#)6
z(w2=C7X){Th9(ZjjOVIUl*Id3f4QkZClWElWc*DTrA#e#6bs58=q6u?lOXQurL%O3
zaLvt2u0m_(NS#Zm<nk#k+{T|J&h7<6rcWCTH!1Z~Jj@*8JfP^+y@ar~Pk}6UoN+=y
zJAUDnxgKfhFT-;l#Yipp1&|Dr*%SawlELhNRC0N&x2v$13+*?=iqgewTXqjsLFzre
z*$kN=_emvTGqSN*l&fXD)UqaQ)>ZC@%zoxvWR9rjlr$*JxKMhe0476#RdB+mwjSUi
zj?g^QZewSR%)b%fS6Xjn1PmWEd=R<Ou2R}nj19rNtvpy_9wET)u;<-^;U92i&Q2>`
zrZlretqI`MN1_JE=v?j@BdU6s@==a5Dmf!(a2>#5-FLU`$?ld60P3UUB)1_J6by1P
zLKz{F+2h;eihazFB8C{`aZ%esL~P6`(F}duD-_ZeUOZ6S8Bjjm-$t#yL$t9fgfZha
zSq#jBX<fv4s@;Gzg_;#RzDwek-f)qSfCi|ei+o1sI|=bYPRz0n`R0`nv4UTI;G@Z~
zpEY}@yBlT&x2W@36lnMF8O|!(($~9Xk{ML8w_l27-vKmMaw>e0$nlCGN~Q3uLGoyL
zZGuM5qX)1ntoJtNn+o4wbzuS|8^}=SZ3xL4D=Hpy%^Nt4Y}eWuIp(YK<@N>a_dteo
zUW`RKeWd53^;MqWXWST&JFCA`Jcr;^9DP=K8Bh|Vlj4<ulDwgERk))qWsC)5CUZbb
z7E^OL=f!d=h*YCw{ZOkRbZ(@Ks8h5P-D`BVR<=XCCmq%dNYY!X0hZ5oed&AOZeM0h
zo_NhFjf|P7xj^f@oc=1j!yKn>>^IdJcQ)hkAOYP5tOTCsM>Mq1#XhrX`)O6Tl04H}
z0wrjCR)X><rGy6nf;+6$<CJp<;0mrtg%_-B!3lX9{J+(Ttkb4>8Djn-wYRaQ#+dPu
zla3GOu(8QCy~#&H3YtXek((HxPi;cJ;ybBgkU-2f@<uAFM7wEOl(1jC)ufLTM#{%8
zjvBN@ie_~%TJ?$ybIl?oje?`EH2aY&O6mwWJ=0;7#~UFWnt&V_F~Mvfsz|1hOC~-B
zqg2}2!8xfzs0Dilp$RR*e(Ey4X0{-YVm2or4yzYtgxsL(Cbo9)JI1Iu;))6+pY~3J
za^cTZG>NeooE#1+Nx+UpMgZcYjy=+rcldY}ItfFnGm)Hfd{#?TiA>y_HEy+LKnV-T
z;8rVIR%!X;JyjVO0YytOcO$HEQZ6`NjYB%LOgC_9Mq#vMVEC#6dgtg3t>oUOgvJ=e
zr{qO_J*`~Dr`arvfZzT#^7rUJt!+Iubs)Tq6qAj|#d_Ai>pLxW;uNryG<nIzd5=_Y
z6P)Pu8Wgf9#NBCn+*eMq%kg8-`=hm862noCb<MiAM+X&xyP4p(OSn5xT8~Hij$KY4
zW#TQfvs`Tts6$e=%d@4QOFTa~^i*oTi;O?HVl$5wTGqFgNO#+uFXFvL0vuzr*rr^=
z3miOZLGOy1k4wd$o`Hv7lOGS0%`_cFuQe5bqXG^vMQwF!GWH75kCJmtywM|u<!<cJ
zLk>s+j*4L*2>$>Qdli4D;Qc%vH_=|JGR-A4XY@OQ`m{n%<U0nn)8MuVtc<qpZLWKX
z_gc`)Gz&8Kj2hk3GO;JbcHp->(<TjbYE*D4OQ#;nF&tM%Dk>awM^xL8qjazgIqwG)
zT-n>t0))4aLm5!LoX~o$>mn1-s-8+3tRihT+UOQ=Gg*I7={~?LyswJ3(=Ki$8<F=Z
zqpz)6;@pV`iqELPwK&`)jTkda4Ahb5))x<LKg5u0Q={uJ%PPe)0RI4Wlh>G8U6dWx
zVqHq{HCVlcZclaP^z+Z6%;KM34*c-r)x&e(_PtiZ3;Rv3264fx)widvBE1j1sxLp?
zKhv7TvP7}nHW&{+YfEc&6zi~>^qAHSUfj#HaI$;4bn!lcBSk7z&myPO;@nANz%?!9
zq9g`Yagjo$<Z;8l+)xK~y}B__UFH@h0r;%@HrLAb4Hb0q$OM@tHtL`e7XIodV=lQb
zEo3rTVEt6qA$AbQny0Y1*%KovIIA0AWkA5~08|o7kjRRu*__n}t7lb(qgNrZ)mbF5
zLnCjL79X0(Yj?)x_4g5ga4QF>>SKcoep#<Yf#t}nq+?~cnk&}GInM@(n>SF6=O&EQ
zVTsVV#_Af#Fo^M!UNO5?k5J^A=!Vm3ZjF?2LtbrW$BK(qm)Oge+fnIrq^Y__2kNZY
z(%cC1$tzsR9D6|Gt0uXS&5gW$(bv+#PStUrstGoUKs{!xf=iZwxf?ahpxY5SpoCX)
zzUFhB^;Wlj!i=E7pdo2Q`;(DZLxpJ(NPNy?i)^D9s+YY)pCNZq`j@#gV2}kt4TNf&
zjtyN6saq3pmh#PWa0;%~qpnv8$ib+zl7{<W;}mYW5Cb6K(n?EuL6s%RpVUDycT{t!
z8RE1r63Q`?#a7>{#7M<$!!^(s1uSsRvU`DvA60E(b}}Q`@~Yu*!cXJHSz1j7;CS6y
zGIF^<i>`|}mgu(h;C)fnKJjDkjyzR-GtSZth<4S4)5w<j3(a%#CitT6m6&Pm)<yRu
z8O2iE<{OYoWldhdS>th>fkEmRmdUoS$$B;RdBe%_lCDVva&SjIQ_P`ACmA(emN_r{
zyc*=23=8vBQ4Ix#q4D;gtoCZo8Ob1n$KtZfaIDx1iZ;^fNC?j&iexlxhWTyzc&?T*
zBgqFpifydIXjOq3^F_xX*ujWCDDsF68!3pZbDGZTmc}^@iaRx=!lG{QDjT@soj-?)
zkCGW!*KDfHbDn6cuWnvr01?=!ukF$m{yd*QR5WmvA=UFp4uPkQmjSR(fl~{1NVlHI
z>ZWKzsbYRr465ZuWjt|;mO{fuoBsgpNPpg}#DOGKKYSX`#_^z0k{EYa*6~L)3hO3Y
z>aL8eh<)s2IAC{E<51{dBRJ}sG6%NCkt6v6oet^I2v`v3;&V~G$W<ud^X8A-1i!~T
zQ1c{i#FXldhKhY=$z_PhoSLS`uvJyFTNx4;w`?}vI;^IlXk(bXWS(<XO>@8jZi_L&
z2Q;Q8NYtr0{L|J=<7r=zrQS<ybHyMD;s#XM=ZYR*jF?_R{nNeAZy*|2SK0<?S8}xg
zhUwf(?yF&xX0*0$)2NV<k~~&Xokz+)h&5-SY97?<8x9Rw1_MAW({|&WntDeWLZA*i
zr?kdJI}ZY&NZL)!8xY<_IKz?TQ??`@-77~n)+B&O-7U19*yolM%juqG8&r%?AsQ-)
zKw*+<9dgx#X*wRb#Tc=d8~*^071rurLj>O?Vcka?L@6E#QF0V8apT1ds_~Lpj^Wm7
z#`Z?Bc8Kt!qgAuGW(-@tYN+3kItY-wkYupm=7v&pvl~=-H3h`28}0=2Q$T&>ZS=_i
zZ0v!?7@U1oo`rvL?<^_~!}nFJquo_S;{fGA8o$Y+EsH}o^^>Z2x@0#nBD^?%<>IG>
zkr!bjk&IPtjd0gU3wWvS0ZF$3R)m`277z;ZKI#*>lX$`U%}H<?OMUB)k7A%wOk@*`
zbx?;hG?r}}930kXRE<(hsuwk(&Q#=cOnX$4(n$yM9a70z40%^sw-L2|jVu=oWFQ<5
zx+76`cf%$;6F?|v+XZr@_ej4W3YZzWR{sG0(nh9KXv(O-?xA<vC-~}Ei61vyXNsK=
zb)k5O%VAXaTMai*N3>iW?fI-^c?`_sa(ESc>7yQYsmVPpG+7M?E}2qSJ=0=|jF@kd
zpEV?5qlLqBpZrvI_W~vZJky|rNTLS_az}t_CM;&dj47m^c4<_Roxk~}TuUUQ3NQ^q
z1L{ykDzcte99BN+-`kPY_2V_RkxX`@BP5!j*P@Sll^yp>A{4gJF((HA4Ae5X4q3Sw
zqNn({R6UAe_M^a+Mo8k215vUD(}k{Vvte`n(!vy}ByfCGxm8`Ee<0Keap|znAdQLQ
zwEn?HBw(oj08L~xSD4&J=-2?@*1d~IaE-eyjN+X>0*GdE=N{hA#wvSxil~n{{;C_h
zhI@jpfl2zO+YpX6uO^D<gv~Yv(ZQ;XM&0LE#t8FQAVwS9VZ0hkm|`#)5McdKY=@mo
z7+a=L3Bjq@NhBLoXC3}3*7_(`;Nm@m_SFL*iZdi1B|plmY=wpOouTyfbHe+l0|iA=
zTc-S}B?#<MwlX@tBTR-pW`@+_BI%u5Z{8_Wrbb4t47&?))oV0Kv1%1~E5&4?jYO)<
zIL~!+qh0?1-uqjAKXmJ|8h|%uM+YOiiI|Yw9Ab)%)nQ;xc%%I|wz5HRmxwdB;7vy=
z<RuyhlM5P?#Y+piLh9gP@y!+w?E~a(1pH6phMR1;A-+{E$Wd!>qd}J8v&JfdP=Ie@
zRg~i&b*$7Na~Ui;99CN663!Kn0uMAL*a)Y%nC(yo-=RfCC8I=EQO?>+i&l*Lt$+yl
ziW6v+@=gHmmeC2Jjy#3~Dm>KoFB)ngA{-wyER692u`k8EQF>Yr+ydVdQ8F62E=q)e
z4#y^$CK-t&<$kIaxJdw37$c0*I|Y*gs>H$(YrMkGyRL;nZ!FSE>Qe*mx<(<kt6<XG
zF<r#A4HQDBR<?InW^ah|Sw)c`x?saR@mnod<pcb&_^fjXq-P9%W2zDZB)o5N20l5c
zkxXhAJeqg<6n`U5b#2NA2gL*iJ|>kuC*xMyOM6!+tiYG&HBM4T$zzrsQQATu-ozW0
z{^}wc@^>&m{Eq0RlG)?h01O9J1KWH94~fS$$!;8OR>Kec(Q!j2Ju=Y|l759%>Tx25
z%KWO%HI^%dKg3izq9o0{3?DUIqA{L`k%7)L=BWKkYS7K^s^l=O1e;Rh+jho!q`ieM
ztzH7$<AYhGs3u=PawOi}=dZfZLde_8E;Ctp(V@DL3vAif=B>2*mUP(d&)r##u~;40
zad5<CS2YZrI3Q#iCsSq;Y|cUMqGe#CVE#Pjp2a4b84b9QsU8Ij7-ejq6k^@aG&^z7
z#WCIwZ2|s6zs*EJ)}-7|8z{pmtzec#2y#XTHIcBmRGmN=P}R1I)=BM_PLzy_C@6uz
zX%*j`(BA3&!whgbqNK!3s^>Kg&;n4%ym>TOO1(+LD{lurD;cgxT2a9muSL`?(d|9O
z878n=>U&J+$~SnbvUEgI%pOs^k%3XTI2`7a=5oCn;0l~KHJByNhNajh0nK{1qG5{E
zBIIs0<l0pJ+pf`%&2K#~sVKNY&N4qW=lyRC=Z(?Z^t`c*xjkz0QfS0bZ6yfj6|Vg{
zzO+f*I6`{{vYI5;w^r&{24E?dw_mloQ*Ztwo=EdwKhov>K6KjX_4#14V%m>wQwbSD
z5A{*Wf__G`{+QKm%n=utc2}S7ujF)my8i$Z$gg7@if~d#n{jcKG49c#E*NC@N&86V
zUHAa~imaCU%*nOn3P+66NvcDPK{z0I%_5f|rb%&RrfjGshni$hC5_(4$%((>kF>a1
zZNs-2^GiLyyAfFj<QluO34IWFgDZSbG(Dtj<nQQpQYkBI?Gwm2sg)KuhcvC%0Hd~J
zlhtRvZF2>!hC%r^ioT9vE@M0qS&v-Wi69P7@$p%;39NE!vg`>wiA$od(;B(8lq`&P
zIjzJuaL*UTi)2@t=_r%kMuc%*kE6j9Xb9s1v3gEynK8952ES0p2v6hW#ro>oWXmtM
zDu&iLICfRtTAy6qB(szlJ9w;Ekz;bsf7-bos`qLg9W4j_6q#bvm3#)qJk_3`th(VG
zkO!K~!+Q*~VBlh`qmn0Ijs;`EsLQ97!J0Ga;Wbl6p8o*U(7|MV#x2JHRR)`U+McHr
zVVz?w(eqXEs<Y*}A5?CKG%2gVLV<=A)x+u;H5nrbaC7IQ$A=uGm9x|DtrS_rint2C
zD!o+$9PkBP&2o}ihf+G?sU!i&1F~z=rNTIO$lIF<2=^j5%?=^HRtQ|Gp7B?NW*F2q
zG2*41D2w<4X!cgwNj8RBHki)YBksJ*)Eb-FYoD_jZhNm<7YEvS<UTsDCiOf~Ho9C4
zoYy1O@niP4$#Ql5B2t!3x4=cz%58TLLlHx1_lmhp<k6-e_IM-3Q$n%Y+!EcMtI5S~
zM}2MO18dNmnf<mTDW}=ke$w0GcMMUNY9&u|6e`~+jKspUMsji5in=SsxJ%ZR*pPft
zvWsyRRC7&=7L|*i<Kmfj89{;OoxRVJb-*j`l#rt|uW%rQuF;z1RwHap@-#HCN~}!W
z{wl>!f+WU6Ft}r$DO|GgpN&SrM<a|-R~IrfY)ZL9cS7)4SfYkA2Ehi7xRGavImrW>
z&9Cm1jjnc+$gBH1bNfQT^NL)MQFmiMmtb+nurp(dsMQMlgq#|+F2Q6|!5vj4#B#KZ
zUa!KrwhtwDy$OB11Now0fEh!mpl>Z>-;i+B?LDqT>?DOAYkP`uw8Tx>r-xCB*#gMF
z@kd1>-N%&bs-c1hLA-+1V_|OA{Dbj53g+b6mmQZS$%M0!R5KyYdlcQ~HegpO)f>qg
zAav~b6p&6NY&h%gzS{XdQDp|G40lARA!t^TGNS<Rt8H|~7&ioYs;KS6q_Pq#D^$YC
z7GM*ef2x`rmn(vC^+7TeVx;r<q@89(Q}@*X7q(i1#6C}fo~uD;bquhAuabML1acqs
z6PmKHxoDY6lZ?{_&B$;SS0SnHa)68uXe~ZOnjq?E!x(hN?gdA{O5H-)rpWB~RUsv}
z4Y+)3NF%^J<&RVq{gaSM<c}1rhJIPscfb)uLzMx_@P6t!(N{ay1btK{@RbS_@k#)R
z0G2{<0IBV7KWgd$%I1Yg!HCQslm42FtGZ->7x6_pA*)HExeFj53V3vjAXOHVH?%P(
zO7tq$N5cXJR;^t0L`u_xj4t2JI4a4O98m1+#|pU=NB*2V4;0}BD7hy%A5=Z<io7JR
zIjNalmmqLWOKOh9rgKs9h-0TuVq&T?!@6qW^O5qa-D^)#A(1;B)f}-p{K4j_ssl%3
z<AOP-$k`}|_=<`)kjcC$U<WlTk`TV!hv<D!U>`A3$_M@_@tvIi01`T;BK*}tkWbxp
z(}p1mki&|EG<qHPy&l;Q$W^2=m10zI+#1a2k|nLckl^R;w6RR2pN|b!McN7qP=sX{
zb_X=Ds>qDY20p&4tz-xe#m^j?YDza1=o$ebxGwGyP=VlzA{e%)%9lTicJ9;;aotI4
zbM0^j=EWXp1!lc$v&O6tf-5yR1Z`D5;5e<n#hf&t{Hr^zSuArIBFM?{NdC!1VnFT!
zNsRZJj!dJkwg>{IhutKua(>N4?y}CP!y`QkfC+gEz(OZDp=}xc&9W&2^GDfCqEaxp
z{L~j7;~5(Zw>{J$ZRyL#S=uwl(XA^+ALS|Hu{LZK0|G%_&1mgqd0|#*2^iw6iwZ0h
zVTe*fpSoitWQ5(wJ<`Je0OP^u`>DTe9FTjP@I^o5gl5rw)e9g1_fI5^@Bj!tX|S-0
zPnRPeX{T{xGG_zps)RFo?X2;VO8kE6knSt9KQ98d`nnl3*T~7mV=irFjg~;b)ooKF
zBZ>)3g`46>iYZ)25kiHW`KB&ZhAc}_24xGD115t36}b?m=TdV<>DL7>BbG212Z|Ee
z*{0gj<qzFTR7UQnJalMzB^xzXXa&Q_Fy1N`5j2X(2<Mus(eBz?aRU-?YRV@<tb_S|
z)u9U1U`?^KeVT?+5&&FnY~q$NGsYO4?eR-1r11d5Ezqbz(PC(_#C&?H&1x9rwRH)C
zwPX~-4%~8nsA-dYY>s|ri{vITpnc$n!4!hsq?Eh1R8e<uJZ$kE4tO*x=h_Rn<b734
zlr}h+PlKJcGyedMu)K<lPU9QJJ!C@>;Fcz*Kqt1H;sMiu4Qh0`zj+vxo^gZtta|5Z
zO#c8?f1qzjnip&wWMY~jMZ1C~z&o+#h+VH1<zcvZpis*cnc#{(%)&v(^KPhwVUkkl
zh&%C8%9AEg{{SL7sA8GopX3JMYI$dANpZ`5C^8g!%yKLxnKrTWR0dg0Squ~tjkT!P
z7F(MWoPs*6wB<6mAIG|_qB3;MF>hHuc&1wBS7(*7Y8N}OdsE&h_-*atggP-f9Ok8f
zfnO3}4czrb+gy7Wsg%GpEw{Mxu|)t6CZiL#?y|tK27>G++6LZt@&-DiE%N(IAC7!g
zc9ki(Sfd~*Z!}`SZRIHPX9pt`>>+ouLO_gvwtP^If;j<Wk>?c@$K0FbaZ)QQVm|)>
zH4*_0+_GE-iZ#H;b&tHXk~!R$AZE7bVn{Q=JXU8|VlP@Uxdi#8lO+{oNwBlaxd&Cy
zOB`IX=QL}Wt)jywQ2o#|Iw{_%ka`rh0R++e`=2{S5d^Wxc8G@?s=nYf!!e=!;+bSs
zE|iuzQ$U8TK=;CDBzdBkqc+evp&)ozE9B&gDIFA!GFq%mVPjB}0{I}+QkDJBWGFOG
zy00)yaJ<x4NTxu=c%pzosk9PWJ1-kWU~UA7I}y%L6}i;m#hip=s>aGoHe6r>;-r`u
z=!*~)jt^wg$?h{LLz1+Z7{EEtRVA|RFZVzM*55p=g9LL=vy<7rMq+#5P^RPBmm`zr
zriM{9(q%jIM26+&6GFRRp-&Qm5fhAdYP#MvF)K$P$n0i|vXCGw${RdWgr4@`Gps-o
z-*p?37Y*mSdlV{I4u0tuY>ABWJemy*nL(}%)2nUUii#_UiCzdJ{{S>^sUUPJ<lt2U
zPE7oO6m?Wd1b?V(5_K0buHU>>C9I_-Dy^JWp58+|C0vb%iq7iREopLOk2@QXYMz-I
zBQvp(lBJLT0EH1|psDwBhU$W|m6le{4(d(v7U7Not1iSXAcF;gaG-OKy5?BqTnPSE
z1+$NP{EWmA-{z$y;gm9vN1B!rNNtpDayvDy)8=Dps#xF*3d~6H4{r^VoRL~vK#3X^
z&&hLxO%frqNDPDH$or-`wC%|Y^-_Ffenv4-yKp!lgG|^#^*LJJFr?&Sv0k83?Ys=N
zYqdmqiQT{))=OG#taHUzK8R;sS?2mR6rd?Pj#{U=EE_5gKImj4eqS}2geu6puu#Ba
zu5@*Abf8Fg7V9-nZZRfP%~@&9>}m-sHyQI(XN#6MMf!OqHD|l}5rlA}xhEr<wAVy)
zN<D+ftiPl$vZz#orE2KgT%?aW9I5bY<yy!%=WX_V2S-i_mcvoJ(`N;k?5|k#Zm|xl
zrtJ(1D8a8Dl4EkFIR+S2kEJymodWDi3m91Zg>KR6UM0)_0KuPEfn@1&Z}tBGPu(={
zHL+$>;8iW2k*Zr=FTNjRANZ}-i|QRaP=!o#1!6f3R_u{V0m?Y>TYpW4Q}-gwKd8wF
z>}aU6j#RS{w_~GL1*cfU703dgEDemQ01v8B?y}&X1#}Zq<i^0>RDbl4*{JSrE+GRe
z@uF@cYz9;uR}Iq;Bwnei`D8eRc+`Q1#%l%ogQ-gd>uwwo*{?vBExSq)lgBlW^%tc7
z0DGu@;(7ijz%`pyk0jvZA0_%(LKzdEMF*!OS*~Mf#(wc$i7e6S`ddvS0rAf@S?TXj
z+gX+NmmqdcX8!<Hb+(Ql*jwiVyj2=}D@BFdE}Q*cWTI7Sck6L=B-`={;<J~nEX>Uj
z=jx);CT2Tk>+?mlcw*_muQ!ps?o#cZf*9kCB$y77VR9vDZX3^3?QY`k+F1VpY#Eo%
zD&8kwYq6RhLS3*^B9q;2R?%lRPp7Q+7U=Bw$mAL}+T6u-jHH&&iXO=%$XLN7_!X-3
z{*y4AO>m>|D%~y&xw5T`gC?syF~Qq3mW<!AiAgyt%})i4(h%{tBgHZZ+uX(~&fnaK
zd<d^=6-tjR-;vhVvojMf3<WZI7BEsngI#$o(h$tRaa7lhB=T-AoOeV{!S!iM!!(Nc
z0C8S<bjdvJGaryOto32rr7(^{8HOv)<&J2fV$OQ553N1hV`q2Kqe@aV7Pqmw`+LS{
zEl1l&4&ybS(XHichLz=E&jPG9S!GlT6t!?(B^gp@UBaD~f_PfnDmoR8)o!jD``d~l
z0X^0JlEL6(A;BIh2QjU|a)64v3s~DtSyZD^v_TB>!)i;MkUFQ>O!tai#t5fRBt;1$
zih|yMX^27bG|!dL(TjYNg=l9o14G^18D$BaX1ea_$11tciVjBOdwfkaA?1O-LS}^#
zMpzus(Zv{>IO2w#=aY!@kGdulDF`p!TeYRjE9jQ@+f@Gm80=K~Wy7Q!AJ0`;H0r!(
zH7Z;^#>9ns^FhMmI($(*(vv^dXdOr>Ak~D$*9FH_SE;yo_X>Pmv@5jeqPs^o8^Pk0
zZuYQEoYzk&LAZ>HM0<Dn?)g_mD_o#jOtG?xd1ew8!1}9OqjW9sje}HH_wvU0jR_ys
zXf&yo@o_K2);!UaeoYqL@OktKhGCOWbumazz`)f?OCiLBAL^_jkjMt?jD6SI7bnU<
zwPZq!`*2THQ)e?rG4~G!udZW9hE`+ORh%F>CvX@&R%xna9V079#ZNh|d890XxdM;?
ztCQxD-Y~!ez@#AbDhVt*q8W^FkE6{EA~Rx8hh;kFX+>pjG03Pw{{Te2c2bGJ6`{41
zo=bP)v3{Qa0N3~uGg@eOqn-Skz9}?B%UNcLR4TR)n&gpPfG?10vPn2Ra%pWundBX`
zt^-*8Qp+2pL6KR|K$xox5Nl%Xy#@wU4rmGV_&!r02R<sMoJrY1HrWTm;s=Uji6c>i
zocN;J*q~xYG1Uw1W=t}lp+Nwa-sP2jqB6&?#ah`*Adp8R?jot2GCpyW;EI<|c1xY|
zu@upCz-eVK8t+lXC8fxffRJ(I)b@%lU@adjij5)Iq;L*u<boUR+BW|H^X))56bekJ
z<VG?Nnsvk~xCHQNQUzF!f7sMPA-RmRWrkFW&1yF0)^-dyZmUfTNWqYif%iaaRz~I*
zE`CeVq?#c`YSIS6jA#D<BByp#og7D$Q}Ptm4+XJgBXBt8ooO7`NXocec1>0SZC3Uh
zsZv-W5U3cy^FqE0WR3Y5%_7C^NrvPp=8U#znHy^HLXrS1aJvo4a7T)~(B@}fW=6&;
zn141qu%eH)cJ_pdF|_yhO&L)QWr~QQXz`HVX=8yyZX$rOxM@{Oa0sg{K2^gjjDhB@
zzaby&qhyBofz3&3kOtg<9y+B#8*VCaF+$4T+YN^Xf(Uy=tr+;@6-%vKmw@d!#azQU
zXixs^P%RtetMaW;q8Qm&uk!fd<1~nE!ws#L9%|cH)5p7oAyJQ-0_N5$R|zN0aoW;Y
zq&pNj&rRl?Gi`vN8BtA{VvvoGjD6GXmE0Jz2tH_#h)fnNHvs<t=B@odJI^qMRP7wq
zQ-ZtW36KW{h|un3L$u*}?uvEDO@y}W6f&IBq5l9D3B@|qnn*q^o+wvoH!>d;Y9Q%b
z+aSrxnj*^JIy7iM$L68-eam7A+~58bmM9}uRyZ_BPb!Jjs*ERCtj@D!s7sTy1Hi2W
z*-zl~4!aXcW$tY(--<~fnSYrl3Gwi0BW;a|S2?0yE7;=%M0OsH4xq^USaV6(0)t3m
z%wwa#u98Ut?s3VcBFYq^98;p$*jEIwr~s=gk8GrojAY=7(Zr#GnAe6GHJA+6@&|A>
z_!XqmE@PS;^ggMg!b%okek6c9{L}rnVv4Jbp6IbKKoKL|iW*y&cgrr^9x+ekBd!5Q
zDZ6nVYA4!TBy-@?B|hOSNd(eDgWO+rum@ELP<oCT7T^@*8mhO7LRhW|`mK(s4ZXxt
zHsGaK&12jMw-qFl^;J7elr|+<S@)a~Pn9E$0;}Yj3Ibl^Y<bBvT(-^bu3LBBJX9eg
zBM5R+<K0<l7t#B{8GGY3S#cpi6*5IW$;i1!d|)1h1Vd=?ZAE4{2d~XO2!GA-85Gc3
zV-a^A-rS0?voS}xl0^iMH1}ML3w;u#iszj7O|_TWk&q{Rij^W~3}rdV;L|SHf+LKs
zK&2ri(u=!&s5UV1Sq(zXe|TVw{{WEv*237dXpTRXW_>{`O?uN6_S>#0Ss7ggtdJH)
zP;uF=NZNaqi5n}L=;vUps`+elnoAJSgDaj-R1he$y|aqm6<B57-|7`z9%E*c+sbB|
zvpkbDobB^mE;fU)au0)1eo02FMj+Xw*yVhERg$Qb2k7@%?@vzV7m3C*;;mttL}g6;
zGtD<N5@F1bxpI6{qdPy--<m@tSzv(jYDosv;QYR-SV6C3{{Skm=N>AXRgqg!jz<|>
zbypVykN*G~qSg-l1i^2*Sv~*-s7lOE?0bF%4ZNFgaE`bFqqq*EYm<>uN44$3FMZN@
zAqw0`hvIhTn-oQ-1y>ACN&BW;ar_2x-4~_@o_NU|1IQG~0J&JqcI&uuXt*~jj4nv?
zM+mK2+!s@jI28nP6+3p-h$A9WuF^=@C#s4`B$dQFu)WgWIAe&7Exof~I|2#fp$2MW
zZl5RmfE*gay0CIxxF?F=>k%?((gFN2&0wWLxT@rWXf`Vu1F)Y1kSLKMB(OdBs2U?0
z?nBKJrNU*DEUXkBsvrq*Xi)<n^>dn%!B6hv1o2C%ZMV1($tLy3V!G9XOo#Z4d}!GX
zf9)dus4+LmhussWA%-#>WpUkALnMaXMovd`L^l$~fkDqXIja!Gt1L~mRk<THAGYFC
zxv&jLjslraekqa2@|GlZ)kZ{C`jy&90ujP=e(NhNyUsC#TJ2ne7F=f)n4T=kW!v!a
zRY-)EGGh^zz@u*Mjor4v&^1*NKIY|I0ry7PUCc{tVYGHCnW2+2SGc#hc#4sO-8R-;
z&ymvAr>NjoQE-tH{{XtFt&xE&pYACW13~6zBm^82%@sZXjf-(YTFVkgx<w`PPcsP#
z1y0`-_5gt*`?2jFd#!Xbdy&T)pO)V19TO~*#;wAGTT5B(mLvf(pkwn)nGr9!?L~%M
zw}bUejv4M|0T*yI>86Kn)Es_ldux+si!5kK2O#*U*h>542{DD2<U6dVsUwCqA(tfe
z_^m#%a@R8%_*ZW0JFUiE*vLpbeA3IVNMmMlue5SAP?EAS1YprOMMv?$p$1F$iq675
z2E*`rs~j2BW5rd16!BM<pZ&K3B#MYA(0VsrlG=5)C!>L0&!x=QI%s3r9aqnOm{K*6
z&G%m6p<isX8SpE?f0F5=42n=(p1;wv%6RHbhIzf4qA})<Th*R0gbpeRqlR+Q6UnOR
zy~MwcB*_fe&3X7kfA)8BQM&Z)yq7Go#kqdZ)p~Z76G3c<Sg}#vQF>a&7;R#W0NlV5
zYg-g5iM2*Z9M_@I=_7(1_Ra>UKf5o%8I{9#{?#dBKsf&ZYKBPyle-zJ&0k!$)2*50
zkwXrFHKo*fW_53bTFG>=<9hL3?xUQk@2a5DwKddnAYelds`|t%fX3^BD#$xlh|^t?
zF$|w0%>yiG_ai4ND7))Iuro$ZK(8>@y>|LF+>ktEvYcj<CRL4cJ}gqo>L;aM+(Bb#
z^A`%CYsGy>s0~9=l=e3qRd1;Me}Aa1(n`X73Ik8Sx4S^=Al>G<I_%QP8cTz#q|(b1
z-7dppjlIxIV;(5wn=7*wOLs9@)s?uTW01OKc{Rt9zFE|qcuZ~O;y}QAn|Z4}9$|Fp
z8j|eaim8^$E42mx0FX7d^ahg~IFu(T)m?{A9P&{`S@Wzon`VbZ(W8PTa=DcM0OGV3
zk$Z249M@Q`B_YNQ7cf)=r^wf-!-5!Nwg~fCGD{@4Nu4V~i^1lZEyBkUBOl&sy7J~L
ze7x=heO60e)(rSdc?cQjnwhl_!mex>@XsUoqW=I>)?KGqRF(&f{Z#(Mi4b_(c1JWW
zi){?Hk%>Shhw`f?x45+!Q@TGC>E9wa(USER{CwMws>$9dkxn@kv-L~_TfFbk73Wjx
zEBl>@*{?b3*rxODUq_(ysV9zuH2A_f5-tadE^rxn992E`s<0{&hcsk&W=I5^NCa0Y
z<C6I^qm$*xAy-Sxp~4zlwotqtsXuU@{wRHET)^JR!C_a$T$Pkhbx{m=amgpPa6s;i
zEefX?tp1Iq+(uei<Sa?fD4F4y&ZS=nI~8=XLv<!L_SFY71a0U2tDPgBEzQC3Drh2&
z;L9A5LeGWZ915=aqz6FHC$?~-JoQCOC%JEpxHzbxXd(reWS=IPE$k(>sT|dv^o5cG
zOLl2k9%$P|7S6dnnvfzaVnl3{L&{o5P&)>l$;*I8veQ#d@UA?Hr;-3vkHuP<cS0h6
z<ONpCl_w^X9j*xYWi`#X!9hU9XBthM{{XdEUdy$PJ2hOeO)UGj;cKOhy6h5bvc?(X
zM-lB6a|>HV2e=Lo-BwsxN4Om1)wqEIY>{zUb2zs{siVr^UCIkEU&UCY(6m_F@)c6>
zvM|h<6if$eWe!d&?CGB@C6$%Yqg6R!S;?bRnS*3=S3+6E;K<^tb!BF|FVOQ;WJCuN
zVB?Z0vJgNZVxFWEfVrnhv<wu*Ap-3tSuIQ?@;n-XGq-Rnnu$REYH-xMosLh61Psx`
zo7KZ@6{}WcUDAJ5jY3t!hr!Ki^w4fCLrErZI;*kt4uSz2fj(%2SK1gJC{pSU)8KJa
zMRkb65sX!}z(VZi{!q3se9;jqC&U1ARpLb1l7t_+mN^3eL-R`2kunW!S_R6kYNp%v
z^C1pMY}MAJUR!c8@&lUAnN}t!JM&rP8e=vYI>!_^2Y2S54XlREr3tx5W`zUYDy6W$
zbZT8m1V-Il7*BMq0Fy+&lHL8C$6>3TqF<Oj)@u9PjIXeA2+dk(SFJLLWL`%`t%I^%
z6SF%I81!hEm75Gt#CWGo4jo$=2Bw8U=fJ135lL@xa&c>J?YF(6l4vA`5BrGO50JvI
zJuT`3q+UPx7C?LvQ2Mu9U0!nH%t8lPq`7XY;3&cBkUUIAFpP6ULRlgvIS3zBaj8lt
zwkfmZzG{G}#~II>R;X4JI~#&H3xU%4q=pGY202s|mTs|381g)dGkaY{Cf35|fl9&#
z;T7K}Ip|dBbt1>@Y~rGl+{A#pe2+%C3jxby_%#S$=+l-!t~v2numwN~BL}=zLe5u-
z)rsKuTPqcYTQM?V;CzN^#K?zC;yzGhRB!<!nIDz<`l(Q?t^%$TtW(w`%PO~2#2skX
z`}Zz#JXDJqkeLq{@j%4Q9OIufV{Rbf`|(hPZnFwc8QYLon$65wL)KJqYh`wkBmjr`
z9tf<?sK2x&0_S}rRme)#g?+#m9Mp2JvfwO-803m|z$tIIou@rh3a7TOyMx_9N$qCe
z8%KbD`5x%yg4wKus^ClxHj1fTs@Yb-G-4{GKLU4lO&SS(>FceMG;%-mD#BSKG92&^
zn#}2u%C{n7PQ%%)6SPP$(eA*_Se=mtp^g$6NjVfP&gPrl0}6ao)!ooG%mLL*c1ai;
zfFs2eLAJLsM#M`HAdWLoUq8JI#~ugON-bn%F6SyK(Ti}IUz2ocX#~$+O*ie5B7cYe
zYN@0Nxq|Y3>qD<wG6j}3<H)L;-`mNjt8W5Aaki_fU@PHy3xXRX$fA+(<b~tx)DbG%
zz*zF%Rl;VO3MzBpQ6W5m%$teczg20X2@Jy+3Vc-@B&38$+Xx*|dR^l|e55`@dHSfk
zA+uTbFjg4FHE{cZ9&!x`*DEN%8;}0#RJg+IegN}U1an)uF=ja#;+Yl7e&C50E!GVc
z45>0^Gn`d>!r#5zd{hYg=)J}wG07cPPg1v<-d4x)CbtUel6<?{S-()J6K)H*9!)H|
zAx8=rcS=VjRO%#E6Xf9bDI>TH`#rtDc%mhlBq<P&YMwAEvIF~~R>FV)siS?o>=_ix
zi&1Yl*u>}YMJxs1DtRNSmWf7>)At{^x5SIc7!*q@M#YE(4;4|QCBzO8$^8nrD$agc
zKXmEZ7_hXOJBx2=IFs{DxU=?MS-ErKy4oBZ#*7c%D#P}da|JsIAaHS2Jc>R?SmgRc
zRUi<ejC+Tn^;!P_REX@@F^OEYX@-k^FbpFhzU!}jFL!@!vRL-8=+zU|VO_}<EjCxw
zS?5v71P;>}feg6oqd^~&$FP!f)orEp7OOO7A;1TUZNKT(s*Vo)5!F-r{W|_dpP|qH
z023Tlxj+h%dZ#o^?S?oTO>JcTKGl7|!SY2c->2G?i_UXH{YOv#03iN@Km1I-pE)-w
zqm1!dKvf`BBa(S0y3^2_tTU<Dcs<p%&!%-V7q{(_e(K2Uus`I5dOXYcl_iv&k&LkO
zO?M^NY2|y(TSuYZ*`k91EIieIp=WU$xi;*i`Ndrv_~q1!o*Ayt=_Y}qBLI>sGpr`b
z)TzciRod);D!3(&d{r-~L0Qnmat%9Wbjs#)J0EcXJ}MbvnmGc61CGTLG+`Kg`5co_
z++7#Ks`dV_x?2GQjtVfwdm@a|RIS&<@H?n2)VVv3SIrrxvZe3EHzhg&sJCdz3g8|y
zOrIN$(eeAJEag!layX~YHW`*B%C};yq7b4ivw)*-=BKzx5O7Z%b5O_bhf%`d=8CzS
zF$l@Y?vG?Ebw6=*=SOz=c&v*mf=8O$>dPDHk~_Y}QSl#jh(rGXbF`c>^Fj6oHR2n0
zGjpB=J935$+m{_;h>igBknO_xu4y7Cl?N06S6qgX@yYX(MCrmqGKU$*Sf^YRJSU$u
zE}l#?5A_p5?1qleZ%{fkbT+};u0;h5ax7~v-B`ygfmA2Np6c7+BX0z05afb5;++Bw
zgAIyF&@&9Se#La4fE5(&YJ>ySwxkjynB;J4DLa&91e|AqT3u*^7C9_DR(@6YND}-&
z>XJYiJZ=hY=XZ*U;dq<eRx9|UA|Y6e;{)PoCYhv|qkN8ds@e)+wvQdu5?ji7HJrYU
ztZ!N@9lv#Qi1ADZMER$Bg3R363xyeF9Muv-l_3%04V4+{qmVpdm53PXtD56x03Cng
zrCXiutjBlQsTL@8v+gKVXPVYoyp3$C6R$Ot(wPpRp!^1NirF-xJ7QwTHEdZ4F44bk
ztcN7`Ok0W8AdY@D3^Pa<4ZvzktjUm#z#P*M66!{6#ZGZl_tMDlG5~PZcI7{6cCS4X
zRaY+@F%^`2Tg@!GA(Fa{mCED4G$e{Z?~zwG1sFC4SHY^%ieYj`Ijrm;&A2c-c=1=d
zM9Lv;+?;SKoc{n2Nyr{3{XK*HkYg1Q0`&W}k5gA+x1MX(JuP_+%xa$CBhNMBcW)q_
zoC?|golP^&GUNb$>(Bc3iDty-eI36?)jWANS7)s27Rep3F_H-$Dh&=WW{ZEw=d(r5
zT1x@v0-NbOOPifheh1nIlU^H37bz&Ov)1L8`)*A2&rM{Az#Rcvjr##3gXXC;7z|_;
z=nA&FBN!(c73(PTjK=<;dYQCszS3`ZAMsvKs%w|pl&td>IXn-l(0-@fPP&QR%BkY9
z(Osr;c>e%u;p+0rQ*rQ)){g>=6swkcPwDO3$7HPe{#dV4wRC-wA?#O*`WF3USAej<
z`B$xacI73sQ=H<u8cFWNtmo?Cw<9l~<rxHaE5`o-SA8(|PHwFeka+{mdhC;Kiyu{<
z)uZ=c<@{>d{G+v*@lE5F<b3ZnxsKVOmMk#inv2u+$rCmQn)F{^dU@pk0J^qLPk<{G
zWn+72{{ZHNfG50HBR(nPPA8$$>LEC8@=JYg88@jT6)u$dO`b<)rzyQZ7^v+PW00cv
zT-iU38Y4EtaqTuon&0{s>M?9euns&|oZY)F3F8#HUb`iY@)*fH@+$2PPirEPms5@A
z#@CbHZKR5H-bNaTKr@}A6`1t)s+VvqvGQ@s)%+KcKgT#V>M`Vum7~wfEjndqs%#eO
z)wU_$_g-mtZ*c_1G7kp5nSgkhV|HuLy=QLL(iyhkdE&X=sit`$?nkt4&}Z2#kETD<
zckeW76C4%bR?f^xBtIq$E6KF2M8|X;K?+U{dPk@414h18g*T__ee7!cLTfbs-2VU!
zlT_11?YqMu0Z6Yb)crELW%QDeSxMtH?TZ+f_?n^hCZ3a9NEtJV(W}!e@TBRLX>~6I
z{{RPzYAG8?p^#uzg}ghhwhpnyH&uxR)5XzKNog=d+FWM5l;b7weh*UQoD)S&-K>z@
zZwyGy6%z?i1IQFi<z!Qu>o}9zJ4R`ot#VZ4=nHs_j~rBN49$cT?QT&FBn8Q!^vP!0
z4mhh+TaM%;AJ}A(v{B#_pEX@Iw5&@R2>emWe6mQ<xaDb=8{Fko;*4$#Jg^UDP6Gm0
z?xu<hc5tCae(G6faUM3;S=+P!0F{n0(5G^BY>a~W*4=iYCW1@p5rYKDt2>C%&JQ&l
zcG0IS2jZF%jdCNhZ9Q7%LoAK8zN#Ha07zcNOKCDkI2oz+6pSBp9g0h-k-iL-*laVA
z%~d|3GB>t}b6RWETyMt}Qo`NeBn*n_VUn&;CDGb-{P4=9`3A3leLUoBT#BG*i^x5p
z)m+(0G;x8ms;e|&`ABG<b998pRY4f2VVR=?YLaOCg_J1_20rLGcLq6Jiu&{6pDtv`
z;m9s<)DE(tSxTIWu#iBgkDRxfg8C$AH*F{CmTJ|IsEvqyz+#^xG=nD@sP~j&S%0dM
z(UaZ{C-L$sk`Sq7;PFx+E8jKO%^S^#&K8n9s0-ao0U>O#z~FeTK8DQJ#kP{5a%(hp
z1`VF-_e7ppm)cA+KZ>&x<b|EINhHOKjCW6H(c~vQEko>p`$5`IJXbDN_|N9A2x?9p
z{iaOu#wqsEDRuxJDjQ@eDQ(%~JkooztgJ@_{Zwd#rct?qgOS)Zp1z3w>D!=dL#LE|
z!)a+7x|zK@E$rDp6h3O1q8Thc--$eVschYxGK`<GUWKK4Hr*pC<)1%_xU}?blxHgt
z$^267lj#$K%xua_xnvmI)jrV46~L8Sqt$xMUXif}KEmYD5qeI=PZr6VWs4_-4bl5B
zCRUOaAQCD_Wpq!3WRE!&=&^c!*%u3LfK;*QP<VwY);yo_CiwlHZS3y<03if7)jUSh
zuGT_6xUWlH2GsIkN|7`xZ2ti0tsiSA{7Jq)XOO*|zcuz4l76bUQPFOq3nXwk-Ppx@
zn&{Ts@$D{us+n|4S2%drAJs`<%KQ`DkJ<C=Iz{W`t*n^-sI<}bDAQ_MNrFDB-j0iE
zi@9T5e^tw;Ly_?x@j+>FzX10lcq(XGw76HblONSczL?d6f%|tW{a3!lrNrlqf5k|2
z*n!4J{89ZbP<xR)A}>v9#1Z><$Msg4ZiTGI3~Y=L_^)LaF^&iS0EIvH5wG&#{{U20
zmntW@6V0vk8_#GqFv65**Q&&Y?!6>g#0NCxvyZXWI@0AQyA#YVw2R^c2*E#rPqflz
z2+urj8ypJs;bRFs*Bw3v;~A**xhS6MJbvXG8Hzk)<m7QxI^<$RS3&a~=Dnu#)3%eb
zV2hf@`lHeEtWNge=kZlf6ymu<sl}dEda?_AwhI%CQ1<a1$|U7}s@m=~wRX0;MiK+r
z6awJQ<S6Q@L}LQ1cLU&diYI(-<VV2ARLMCC%rVU|j8M$487DOYSVwyz*%-Ek=g)Pa
z^z^oq;qFnGV+0Dw?75yo=@}tv*G9OQJ0M-H^-U5QTZN4a2)IIc&x#fOzjP3Pyi?H{
zTYaGAk97!8hud%DJk@~?Vg4bpsv&F@fkVmcS1>U`Gu26^g_#|hut!;-Lbp~~3{nO?
zbSo!#m~eW<Z7xtw{?6l*=Cazwv%z-B{FDx<BtQn3N=lvp9n<Y1RgI>1z#R`Y4-9><
zq&9l4VnxTbjt6uA6?VBhqFum>85ThqDn>!6qPQ^3$k@XSe^ip~NmQpR=739mDn}@x
zoMchAg|e!7C+ewm_d}_uciS1QJn*W8kp}hgRwuy_>qPc#S%ASk)D4q#7-ZDRCiNpf
z?MTE%z?Gsk5|qpC2RwCEI?^)`cnmyMhq?@#_hb5@?>5dD50eo|CKQaP?a7$Pt%@xI
zK_oL|J1b<5y0X&!HLGfOJ7R#M6WJK8@2CF&PVH^V%Y7kt9PRO3-AAb4!^3vXxII5E
zUTTqqx)&PF(zU&*AAl<BOZ0xPceUAluk2T<SZMY(#0z^=2kZ*Ax3HOx0{;NwxS9QO
zf5B4xooqgj59I9gy))2qB&#jN;fU}nOKs`91UY0ZYhQ1pvmc)nd|Ffy<2;(><n@fw
z{!HlO^vqHICQ{!@w^NAVAMr-Vr;s>+WBRR1TS9~57^f&qU?>%edfC3&sybLBJ8!4H
z?~-6ttEI|G@GC$Nc*S!8_f)+3D6wLJOBRsCXMIT?mC4-oYybzm3U|k5F_TEMO^vcY
zML+#B2l-NsGb6gO$>@qza;L1-f2p1JH?<$4v}pkIx|(#rKQ(9=m8C2^3UAa;!w0n=
zqM+%@+!bCv=xdD@Cj>M|$NH@VssIdp(_<=Blie8V^CwM;^!VDkF;~8lvzshn`5&QK
z4SV$U+5PKNf;<}bR0ACOq>?E5Dh+PI>iUd+Ou2nK4o?Tm-k|jMsb?z*A!5H^RVzYc
zk8c}=eOG^^SzV!7Vpa$2Ru9#Grgql>r?LSY^MPIMC$GYMWK?nWK8q;xjh-OMm^tG=
zRP8yF-vJt~Jyq$=M@N_ZkhxLh4l0_)6#d$j&hM)9SaQQ6xU+|s4Dq^>qeU*oR1x{^
zogg3$hx?{S?U;%m<x;Xm>;t@pttpiP!b99_W;rz_(b;r}K^WsT82HX4QJhrl=0m;L
zKUFLQexi?Vo?CD{c&uf@`{a9L1%9hntjMQMb=-G-8q1`jCm@UxJWya_CghI=veeX!
zXDr>**Jeu=IjHvTVsr5nY*7#STp-8C%@=I(o3u<|4$TV60{e;gM(J>@*J+%CK!%#k
zV5@EgeyG+{G6zx@2BCrtyF_?D-8w*0P`TsrOfW+2VgjfyPGc&#R*#Y5hC?BnbbJtM
zc6)<#j(%CFLbqB%VtEyC!^LJ=LdlaE&U>w{xd;|+%D}lDR&Lf<N{f4y3J;OpESMQx
zorgSRic5G0xYKS>anY$}hupYfA0SjLS(vB*V~P)u0$ei*K`d(PN0DT<Ye`0T3Z-;?
z<#y!fgGOnk<GxtQ<kfPGj+vMBE}nGVLH2{~vCUT7xROzd^iNRO$A4(*KrW*>uQ!kw
zXLKADHJ_$4Ma8?Maw8xm^UY~(ZdyPA2dc$cPlrxUbIok*W{yaLfCFQ*R>jbvimfOd
zo<6Bno+QHZ3Bj(jxJaXQY-IFny~SI0-hZQ3Sq3DE!J=h6^Hkc?1x62yj)flt`%4zd
zB>YWQYhb_0hG|&}U;&7;9w-@HF)9ZcqU8gjpX!5*Vp2^~!bK?Cj&nunt%5}eKqZTD
z^+oALOJMg(K&zNUvF-yOb$jSpRx6^Q;}ue@8+bf@RJv8y?C!S}AQQo?n*47j2}K(;
zSr$C1O!ic}m93E@1pU_g&^Dmh$u<Bv>b%#|SLt;can38%KTlRk<dP6Dxv!sTVDW0U
zw0j*!MLj>on~fxoV6U2Pv2vEsdyd!(-77@)$9j*5?x_7$e{D9OA{PMQ@J)B8DvM_#
zG2GHT<JDS(7y6WskWe2rn7T`Oc!&@7qP2k=IgT^g@m29yI&x(oSDJF&CpP;%CMa!+
zL3T39r!bN>!L7%oJ!G&E6#OakSOaY<NHD~xsIHnwqzVTWb{z7?=`yU^c;)Q(>pxIi
z+{QhrRf+u6=6I!HlapQxVW{8R9q_vhc&&DY>(d!qd$>mL{ngONsf_#J=4H`NJg!eg
z)ZPzoX;4qq2OWj2)Lz`MrVpG|d>X7ei>|;%dnT_fcJ0Crhjpzq(UWV5=YF=)mrS}1
zY<>(gipaF)JAgntt9R@9_g<m~&IeV9)S@`|BOf7LEo5S|w2|J?P5WzcF%n2}e2OB@
z(jwcPM&V7<cQhN^Wa6A;XxwCRT=_P*Mzu}Rd!^sLoie;{fu2Qr7N2_s<OwVip_d%3
zc{rV9lrGVVy3=NRci#ksNcuISNv@We)8!d8S~ZbwTr<@zZ^k{jS8G&SzMUQQzs*Ae
zD=(z#?|4KraUkgZ)~8FoB}6k0YtmrP4Dh)0aPnf7DO2q8{clGadoxCvQhW+G(t3e}
z7^XP?0Na|{>l$o#F%T3Sit}GkSYB9P1&vNK#d9?pd1&%`*q0toh77Ay4{syq!Rb~P
zsUrMbW}kN|$rD5XW;|D)S>4SLUDC4WyjHVFxfoJT;zxDR(`uofHxm|ZJI3jred_%d
zNHrFff!g0yhq;RGJwz;QeX@MlzU#Jd>NdtOpt<v2SL&S>^G~@_(Vdy>3g>II(uCef
zt4!;9eyK?;b9{gmc<r|^$;AO>ddWFnM&stMqKr#!1~M^KH<o*446BS9;=)PVXG3yM
zj=hLY@@{GvkVd!znmp|m{P&8knr)6SMLccrRd(qOWddA;!Ktn%3kDT=#ZLo9@s@mM
zg^_*dAx{+(x5)0g09pOkE3}S#saf4uY*}yWh!IAIW(PiMMTKBe%5$2v$|AC<R^Ut-
z`ud|T9a=6%IHiI_Gm!rP?NDkvoE1(e-sXjn63rSp+<6pScLIBJkbZ>)6_W$LUTV_T
zG?o&I03xl)wE<NXH|J~wo`q-d8coW4){jy~F|<ThX{;p^60#h9R?R(EEJ->HOQ9GW
zS0sH^wv~1+4%Qogx~5W=>Nfyt*Gy<+8}YQz%@wq0yE0dZUMwfbP!2Kh0|u@fv0O)i
zRhO*6kH`J%>#{yzS8gU|M?6uHGaGl0hU1D6$YGEGK4`r-D*_4Tm2!YkT!I{_K4}s~
z0|7Z6XuVD~j%F${b3uj*gtFs3R(HTokR*pHG51e`K$4C#QNp`{!wl2Vh2V^u36PrO
zYpDt`M(A>wWKs{Fs<(a{9N^J5Gb&sSq+nA)(<4T_Z7#AN8j@)WxMLnOLABFKYz{C-
zMx=^qb^!Q4S*<t80tLbnLmp}I2Q7i;%~m|j%nr~P8qxY=Ou5x=R0Se2*`;l_wmp;k
zEHn)|Nn`>g-cN0c-D!Fxaj0pI=K7;FjW!z#Wk{4~$)m#UeppuAT2#50ETVZ|NJ!v{
zHTb9)ss0!Q0a1QUDZm41&1+CgqOHV(8*)3RA<jiLa0W+o^~OQ*=9`KD=(2YVQ<Rne
z08KQo-SMeVfytqC5i^Crr4Ge$PcM_ofDJ0fPbfYkvr_1TP~!}H6*_^qO8)@F_^4+i
za0`lQ-M0m}skd-0iJX9Q;GU^C@l00v1K6kIb8hH;QQJhjA09%I8x*^@9I>d#>jtD;
zE;ouFkczE=no`XpZevYs6Y)G#qf$n5{?z<-0G+XWAnwb3R6)D}#We8PsSu7j#UMt5
zgVjnHf*Z{wz!n4wMe<DxvQa2v$8a1{Nwz{4Xg_qsEzT+5#N&_di;WV@&#OHjr|U5`
z#8{`t@)hIWqxAlvq}&@<jNl)O{nya@a>ECjtMxvI2D4!$yov;v_^|G=YBb5Kk7cmQ
z;h#BNJ1*3A%lS1t!YGw@E=Du{^<(N?27MAnNx?6kGu|qpPrDY@IDZ+gax?|Sdntr_
zKqy}S05u2i++D8Ij($d>bde!3hW^bBZEo()$gFnuXz-no-dNl(vaFnvIi)<vvg5wR
zReEybHh_oD<sDVjVOkR=Mn0<B3C||{mp>9PDlOqg0mdmVBUXi4GJB>8PqnnCM;V~V
zOYWm&qV8`7sI|8%b|nKN9MzV|grq3it>&xsyH_y)8@|mfkV-p=k*+<&!kkkK;Ko$0
zBt5k<c%zBFPrDyg3@ptdWf>J(KoWM^M(neF)1tUwFjtdPzqHZsAbXtwLY69iYxD6&
z$Q1&gd^D$N9ahHDQyr4!w*o5-9IRh_o;+5r#^nu&X8Pb!Ok^1o##rNn-9F{_#0GNI
z4WmmmpW#BpoMN_Kob<~V7dPD=cGgW+w;rB1Hfq!9a%XiEP-vPh_4K<{Pqt5Wxzc?r
zWo@<RUvcX4+TJ)-V}dZF@G9EFOp;Oy3=hqDZEvh($-;Y4=(L`h2za&!ZETUCNMZnf
z1zOo@a>&58R8_UDj5hmnxinxao(2VQGV0u&MC?OOmteNKbTJS}+<xfD)li%$r|tk$
zZ6|;#hd(WrrQr*YpLi7~1Y)B@_^D71!RDknB)Ag08S1+~B6H0#n1h_qZ6(PP96O{O
z=9wnoqZF#@srjVdo1oD38SjeW!K7T2Bp&G)5WEg(r^f&kob)-Qf5_&$b_PvG#fxXf
zB%Lb?M`gECmgfh$kgvoynigg|{{X7bpCiK^-H#uUJcW({@k~9^D;5Bnm3FZJarah6
zUgF#ijtT$=KkZU32?4sO%7FOID`k4CV?w@8lrH>6c&@?gG>YUY;8!Upq0I!*D}YT;
zNwU;!+B=9*!TeX4db{-N*kgC4Cr2ekdg0s#2*zofet0-4d#&1Ser+t1gEME+<IftJ
zK5DzSp4wv^kutdNBAA7P10djduXXibrL1*CEfi{#b_gBUj{2ufyVErT4AGDQ;Nyc{
z=hMAk9<5hW`aG_?(<i6-E>TjbUPI0XXsOo<vBWZQoYQ7e?IeSY_e?X!yry&2b<?ww
z1*<@1wUM0Qipvm)#64;Ci8ouF%s}&5%fv#!Mb<pgu~@CPFr(Ybw<eo%V=g_l+B}Nj
zNGeIm6+CGa!OlQ$6f978jF|SPUTD1*UDv4}f##w1f)OIW8Nn28hlai~?D&o<2g#%v
z1eAObIj#f-1wKc!T#XmZ4CTc>&)fEoIeg-p!b@yeZ!9@uL^P`xCyIrGJE&8PcSFdo
zCEFp+D3DD;XxbJmb6F`Fh4DVwAoME#08)}P8%f1fd(jy)7|!1&mGBP7+B|F|P@m;t
zfIg@xV)og+#>06PEVD?LKJ~Z*9p<5)<jl-nM(lG+L5(lPb`GjLX>)i8Z;&-C9@EA0
z{{Y1g3Msn{A6cSAYONtzS9>o9y2N_tMO%B5a{}dC`D4Xyty^pX4o4hNw<?!*b6ZG(
znE9$QN1H8N@Oe$7hB<)Sn$X)y(rslp$BL)bY-Q8$+BZ@GJQ_02Vh{n<Bv`a)q~;|j
z;&Dz^-yYM>C}`wqB2Wm$8a=OMggk-GS$0YwhYfHLo+wRc`LZeHdK5wp$9m*qfz_E1
zWinXyYBCjaF5Vb?jaN*#bCbmzBNrJb<SGeKO73ILR>%nCHcmRJZHDI?PARf~>6KAZ
zY2lVo7<WoS$Zd@Q&P`7lNn!!Nl|XHrHu8QnMWP09NXPq9O(wZ4g{E)6PS}fuR{n*3
z5$J0%Z)NWf<owr&{*7sgsp{bzVPhMs=nG;kq6(@)D8R2DlTTW?WIZHvUKJ3XYWLW&
zmpox>z`aB23y0JujJp-wK(9~r&a$@pWTa%0I2GlnvE8q{VgQq#MP&61iYX>-&_lUU
zJ*C8M*_85YuZ)bt*iuDH`#sa-MsfHQbZaUu#kOKkoL3w9d{v!gI_#@knPO0`xHPRa
zPT76{+CU}0>e+OQn}fNdBl{K7dVb}Oz?jdRRf`ng@e|(1)s&BW7VmC8TDemWCCAFH
zAJWpqH!70eO)>Oa^iUQuf7+kglIbveu&PYj`Wk32ZImz`<bD2Y&=w?1Qpx}ruQvTU
z)9<35Q#?%=2gvTW-le>I4IRv3nTq(X#+AQmIe0l5h_7;@c}J?Xc$?Hx#P9rD6h2Z#
z+@ug{i`4d0TwZ?U<r$kNHE*Qb6KWNS&MS$mac_EkoxC{IV1g_r_>?2fE#o<m1zb>Y
zMJ>JVT;(%X@+!=CFF5+FGWfeMaaUz!wXMOpF71Khr_?9BwpD9vw>*kE01wB_Na_BP
zGf49DZ4q<8U#9M-X(O4&)1F0oHJr&Kq`zQSnn4_qjH$(Ky)`2X7}?HFeAiRa^1pIX
z@Xlwc!BUbp5X^$#IL&6gTP?C$mvE)eRA#Mp`+XgmP8o+4=CezGaVvZB7EJMzU0r^z
zI5E@hm^6B4mUrP0-CoMlZH_WmJ=TZQSH@%!f<p?U5-eC&QC3<hkN%>DJPh}W^ZuKa
ztm!W&TU!XcT^k?V`%!|!pSn#!EwwuWvV{Z=%?+x=$!OB4=y|MF)~%?tGDo{;>x%T*
z^Fs_SeH?5!rIJ-1%A5PREOj|7<CHfw72U!#Sq7;^p&G%smCF|Ut6SS&egb3QfnHlb
zwDMdyO!QHMP+R*TSypJ9Y2;O0*6%!<LBY)xVx|Jo$(_cFNYH%f?%4PPQC$&7X7NA)
z$>X{X$_tO(GBaU(RjbTdKvo~sG)C$-F#e4y$oUH6mP0kMi<UW{?h9_fG)>u;tel!1
zW1c^gVTq#;$tB6d+l_Y-%|x!33{?*zn!;I0RvSeny_dHkF_WJ)YDso2Gp<#jToan@
zB23J{oMxlcruN1jgtD31KoB14)fXsOijyoaWB&lS<Z)TeT_m@hw0x^pn(Xe3H~OnR
zt6eVP8C;sPO?E7p9l9gor8%oRZ)X@oR1-sUImB(WQQAaT7V=@qaravCLgRJ_OOmF_
zK=C@i3<q=_!(<dZ)S$8s6ywbd?zt_TbJcxmpECfO7xywa6)b1lj5csZ7nsB><+4o*
z+hkwOSJ46WF&oCSA?L`d`59db5udNcS?V!vw+fyGQ>pe}<fP`Q$hjc&F{E2S`FS+O
zaIJuAi4rj+<MB|g#eO>TRai%tB;;~GG}xsHE=c1w6Uc^KZrUn8bNsyWDsG}tu(G*E
zvF8~2r$shMCAd9)DvH`-V+syG6iuwGW!epC+?uc>L8RKreSDVDWwP9w_Mc7Zap|@x
z8Ytb5m0~|jG_jL=BIoFu^rT>|kz2HwscwC;jIzE79#5f)U85b-8|L2;PGn`rJ=XfJ
z3JF{dssXN07xP@HmE`qYsB(UXng}eA9PkA=0($D0xC@Zq?N5)cd#U{pP%?0|{_qIF
z6u{VgikS!}^GA{kB9Z~zc&DVS7hpIP$84VKfnB)s_e)%I6PRw~af;$MbK;yCK?&Y!
zS)pVc@DD<nH*^L=7{mOJ6(aU=Qb7{BfClGo1y6NjHK<jPV3C?vk#3?Tz&^v?YosNB
z6~JH|oKxc}J|~)D2!jKvk|xJEraJ=I9x7<0kK1Kr$?#}N@DwAGTMQ`>>~EJMoE3_L
zid9VHpA@!1<TEHBaY*B8f#lML_%6}aG@Q0iRS^d!K-vXJsHgd4eN;#{Hgk%V*_nW%
z`5?`>Z;cUd!DUxrkPb~oJ{jCH4LUbnq!G`G5>B}yXvTiJT3hNGYTsJhsysvFK<>N-
zSxe&s4VwCgT(TFMMZ_+-R#RUv`hwl9HEH7?5UxP3PJB_tDv7QVa$JuA$`y9Oq=QhF
z*&QQ5RE!#~dF43EXXw<{vcweopUcfsF>|3@?#T;=HKMbT%xp;i0BXwUP8#Hu7+!^H
zEhkiUjn@Eqr%!;Ogt=(c4{v!VflRrP$jCy!V--4FrKX|oC=v{03T5TQvhSB*3dcC1
zb}<}m?X)@mg+-`AB$jf&0aQ~Emzpu08eLP|jsk=h&(%f)6*{ZQ!61W9o=gQu(`g-=
zn&ifz*@he*1qSmr(Cjb`C6H{Be8xsG=9?wKX#wvZYA12KdyXmzC0}$H&M91|luvVY
zy@II5D_QC2CcF{D5|$)ZKTfrl`u$;zOS>Nx?f#C@W74dUxCUZ5KUK}v>*J@7<((ZC
zidp5)LEf6st@QYV%Aut^pT%mdZRNRek*-BEMbqWHm~cY*HMOy_iq0^o27H?FdaY!o
zEz)++U8mB<Dw3oNrfDe}hL8f^RcNZJHi3%ZFf*ETe7`+cGE$V~$+;yJz=IvNJB_>=
zOO3hs(*|>jt-Y>-m8&F7)QGFJx0;8@6)anU&vfzZSq_gq;8I}jEu3Px%LCR0M#S#O
zrjw)uta0QMT)d1|1A&$_s@PM7rQy2>!;*2$JSvsOIj0~c3F?}Ekf@SM!FDHH3PyAH
zT`3vh)Mk=Sx*01TNXInb3l2D_@JZ*YcsN>-ci9-Hk%D@p+s;^KkhV@~%0@Zvrw_1n
zD{b45Fe!>hU{bT^<It&=*sLD*{{Z%=-ym&8az`de-PS3)j~S$9CBGHK?pz+|H_M=;
zBWFBQkgy{hQpL4-VVY}_TO*1qg<<c4Nn|C4;ng5z892^rGR3*`N~%cWj`rjYsUaH~
z;;MZ`pxSFT%(F(KOnh4$)wXbcLX?txU{hnt@y~R4WRz5uK98ThL!sX2`kO;KlMa3-
z?yH_C+F^hJ`mcKRK8FskX2{Atz&<Tr8Lnx!I$ivbOb&N(Ui;ELRcfQMf4P6`@*b(_
z-oxJy+W!FbRcltt*6s4a^I3^Zai$9r`K$e5+(O?IkGjo!i|%2oxn~WJ4%>3e@g8ax
zxoz#WahjS&KG9IT6Wv7{Mh7XD@@S?8bIa~Wv>X5^{{T;!M4=V(r@F5O0l9pUMd<Q~
zCr}Ovq6BR1Vp$o9<7lSX!M@>uZLALf)CqJWh&TGasEcT%lQOnLFyfOYU8Q+)tYr6a
zOKw9ngD1c=EYoECjwq>YWoW~^hcqnK;{zukcS(;rZkV|9Z!7f()#GP5JXHi_q`dI8
ztGZQ&$=t3+I2Do-tjs|hd8^rbCTUSYP<f#weZR+(OLB-NTt6Obf-G&78^1IKI^9^K
z9Bs`$G!aUhdShG)<nxkxq=Yigiu{6ms6=bwUDk<}<O+;DF|fcJo4O*^WoVQqE4R9a
zSYk0TZXJ4{)uP1A@2zYjy0-UGf5^P`Sc_?PH@4##HR@8T%@)S`=CB^7)7r}H$fM%N
zIjpTy8HC%&tbhZ7_@gY?0#0&2HA$ySf&p&o-Ebq^t--4zC`-($7$Wmkx`W1G{v$qU
zjgoELU*qP2)X;1N4MswwsrNtl(bl?E)$t2y3qF4p6cET`+<LD|^sC8ZrNt}}0&$W`
z)-7ItW;ToPV)q>xYY)?pQC$p+PzQ|Fg}>=ux~?RZQ~_S8=}%Uh%aya1EH-hRR_<6L
zk~}*Bk;gUVbzZNn#O{?HC}}Xh&kE7K4DsKh>MjI6K&`8K8%StDwS`!L#}%T~v;!$G
zZs$MUCXz1n`9j=6%z*b)!`3op{{X1XP}5_F?IQg<(ngPb@+>=ibzX;meGlwEhz*JZ
zPr1|GLpTff#aRKQ%A+sEUmWm$OB`R(gw$<Lpi0UP+|z9|3t%v-k@bq*%WtGA<PnM)
zu5{=@_F~@EPDP4t<wL2?Dw8u%=@#IHSV#O-ifB)_3kdviTxPpz%g1g)o~pv$=ThJm
z#a6Oni{TNuOSTOcr|u3iqNiU@+^{)Ok=0nmJ?Q0)O1C$e{&=fB_=&ZBl)v;F%n(ot
za{6xX0e~6&)wA8+md5dlkM|ek{{ZUoL-i5zm}~M1G>u9n_~3t49p0UFBwHq6bKuc$
zE}(P%e0@-N3wG*5&&jCuDJn>n&t_v>&@Ap$#QRo7<PlX?dQ5PkOymmE$!YD(T1G6#
z&S`?)GN%XqtCOn#0CoP_Hsa4H#;ng=Xd*-`txb<ilHMF5=C5XUhCHeg1sA8wZ*>;l
z1AS6r(yXqZ14~trF3f9NOoXsgO9D8MZc=M<`dL559m2VE=)(U1_P;N>(ETYs*cQG>
z&BqjMRZk3jR<}#E_N~==$2D5oW-eA!3CJ~bF}XHmTf{@-8Lj$F95B0GnX_sok#fqf
zRoy#AAdUDP;<B$5{HOdtky-<%-j^>dEX1B@n4+2}@F3e$HkLW(a||=f9BL*}^u0n+
zoE*{G4V~q^&@%zS?yp`ziVV_(A5|n$Y1?-+{M5&%!G+r3lFycEnHIIHdyszBK?BLE
zXrqV>vS&4-GU+l8n+`t}4EMTpOSU_G`KvNd6u)&9#m+q$S@fu;xH2Li_^IQuE5T94
zTu(gGkNbN~fcdB)wU{|+8#(b@ZCrHq@a(x}$oOoiyV0VUZ&9^})m6`@O$j+tR<>a_
zaZBwZleh}NmGD~~RO8<$^2@nog85_iq&)pqx?Hh<7K!-$R^9CF9PVgTu=9#{?BE?n
zxcbFeENRsmAE?@<j0*0!C4^7MTvJ88-?{$)qQrky=qUthc!_`Fxs^kWv9J76`*aWW
z4+<xr&ueod1xt3%^-Bhmdl@aT^Z2hr+l&Dk^Zx+Gx@0MgDE|P8e{YT%U+d-cd8O`y
zdvY>jC;h2l&@U~~O2yChUXHtu8$ka6YDY)tjz6lgMeVB>_0qnKB>E-fu;fRE$5lx`
zr8OyJE?^wjtBCmFasJe+0V;QK{?%qExb(%Ax^Kbb_a2hg7Xm1S8E5HzQ6mB4UDfJu
z3*&*2{ZwAT2cw_ru9Iz0t6ekZ?eXP;eR-<$8-{KGUiq$u=t%3de{}oV079AM`LD1(
zPYyuQv0euThHr2&RlpQQtH~-DzPdDx69qWr{nE&UE4g`g2P3Mfx^kB#hy)6=mGHwO
zs;$-*HTk3GJ}W+6f`D#i8;M@%aWTQibsU72%|z~Vo~t`!5|$j6?vY-hcFlMCGfQNk
z%So9f&g#3;GcCv-Nfnrlh#=Ol(QEH&Q3J><D*Rt6KztuS`V!G?w0MDD#%n~OH}1z>
zim%Yew__5HFoKQ+m=XpnzLjudWRnyvxdsIw832=9g;{WXS7+u9I36kD226!OE8c10
z4$k<fk%P&QwJW{=7~-QuOh~}oIH@O$fsmwU%{6v1=OiDhdr2c8MmbuX*#uVDGDb<M
zBN<)U!Ob;-;}oOfqv-KP5F!<giDw!9syPa?kr?8*H?}|>9_i<12GfFRe<2}Z@))Vz
zNdUVX{%IgZ4q8Kl^-sH%WZSiH1xx0LF*2?hSdXeD<e!I<LgN@2p;VFvd{oULU=*mu
zM!6z5s2~z+ztx&UkT&9-8t*tf3S_JUq5zUkF<e31HjeyMS4E;z?R=@aY?4g)bt*@b
zOKQR%Bs(@R#YXN~ez8uO2$UV$uqhap7yto6KVb)&;Kn#oMLs9qfxhZMR4I*+5%*F@
z?T&^qR7N?YmC3)4(Q}qJjU>7IIsgIW^HUa2{{U*CQMvQgao}SaHGglCl0(Vl)074T
z4lzwsA##4H`&DBNoMxurP{X*!(e?;AubMwp;`TjJJYZlFO?@yJDetjgJASc5Km4g@
z2cN3Jtm!iRMkYByj3(drr68+-qjqXZS|J!jA2Z!S8#=HkpyTea*>P#6$YQ%dI{Fo;
ziOlZ20sYoC$g<9|G32*ZwzI<`mQbe^WM2V6aM}qQA^8-yODs#Y^1ak*{{SKom8V>L
z&kl2ujAnxvWN!rSzv<iLQ!eG&3J;gjHQH(+$UHElxK#kQdCyfD42G<L+_JL(Nvf-n
zBrFk|a@B{Zh)J7q<eY<46Wo-*+)Y&EN)Erhidfb#pkR2a_?B5E3WKwOLr(Z0q3*Sx
zr&?T^hNQDfxrsS7lRjmR4otrW7nW)$+<u;Vc`R*K`sD$c#~B@0rTTwQlTe%h4&NrJ
zbgNgnxQ+;yj<~N;(JWI>v{VW=W0PJZU8`<RPquq)7L`URE|6V~idn*_fOXv#aCoMp
zZW*T>V!0eXPLD?+=bBJEJ}H<vr$$EMlf?xtX_27--MW+kjCrmZ4slLwXRIFTRrU)J
zK?jjjCmH*wgA<Z?rzbp<O%|6z$ylH;VoA+86?<xo<hKWkbFdwEML)1JvGO_UkwXPF
zz!v23PRPa><Laj!kaSEjhU%MuNg|jz=+lTGQQc@1M&n~{>{ov-`==j}=9C2kx~auJ
zhq0s)=AXff9A=xbj!khOD93bq2V!7@$l|%UkZrCkNyAq%j=`mrZ=nAGV_&{0;r=^!
z8fhMB4isjS$ZEyle{{JDKe}Ngoa2g8!>Tv*N)<^9_f2NO=9FX%=9=UYoO40l1tB;6
z3YIn?ebfuXbJa>D3!D%3rH350884wrD>ow*CRbp^MS@p2#UkV!W}Y&AF<L~!?y?`K
zUYn0qv3r;k6QIu?Ygv)jc%>LQQ^+-|PpFm|sm1b&vf^1H<1U%<-nf%RzTKA&xdb(1
zor=s%m?u6f+<#d8Fkp7nZI=qbmcZ(~CSE0VZU{Zs(R4c4>TxNf!)vsUPm#yLGcz-Q
zAN{GU8Baug&}}By1$+Cc{pNB!n%tRzq5lB-tOnDZ_^F^pTcrh#?9}=djm7QgNI=i#
zx@bkVs_{#b>fF)Xu7xjRRx`#oWPMh~!UXm}BQ1)`*~GKlM9H`}f%jV!llI$D)8tpN
zSu?+pn=D&)Pit<DNM-;Jx~taVjYea209EyrF<rt@Ps{G9{YPVO0Z}A`ek!>0A#uef
zX78kFEt)WR#b&OdNS6wK$WIl2bR32;u26MZJwoNbb+n8XHPP^EW9}pNn0to}PYg){
zA`cwqqPm;ih;A8g28DuRBm<+>Ko&?ut+#=XH7&ej-2t0-JW!AT(%_w=%~_$g9^bTn
zVDnM1qg8A|*eFs#0-|CWKq^Tz`%%8xR2-aUx@KtMAPljl7!0_LNFy2VHJkNishZn*
z9l&_4NKbYTm>H^@=s=12%KcV+h;(`Fu>wLoin+3U4Ue2vb^Ia=qU+@KQ`*SPKqs0=
zu}ip>b`hL|Ra&YtE^~q4QFe|@n=_h+S_%|4b4>an=>GtuU#6p6v0YbDVlBbQU%KAj
zX;wCJ8(5)H5^y-IFX<oZGwJrpqueHAJSnZ^#n<mAX;=83Yv*3ClUp5ASs%y2-O|Ss
z$8qcm#>(2p<lR96nFm7^S*q%uqW=J?{^Y3;j+9mUzc|J!P2t8QP)GGyp{|@Gx3p;X
zlXiB4>ZoN=71${yZ1k&j)uJzIR$O)~12&Iqa^R@g$H=ct{VKBm0Hw1d{DY1Ot2Fqu
z`l+>4{{ZwRSxXwThK)LpmA*gPm-Z4yKlFd`UWy75a)T8di31<~C8~2nO^rRW5;<ny
zDD&pBkgiN8AJsZLFCNA}IIa0eHsjh;Ob}b+{{T!@f7C(^ZINc_KGB8!yo-{kc&GbU
z2L({p)In|!F^W?R1Ng=&zx5ekfw=lHq6?$)Du1d^V(WMCIIXJ120!%0C`dp502r%R
zs6ViO;KTmf=$wQ<nsP&No>11{BqxCwrih>inAV;;*H>tl_%N++bkB{13R!Gsc>e&2
z&2Cyde*Ljbc%VHX6tdM$xRMHM==0fhdzb$JNi-z7T#&vPSEc^hKhgzdJ$n?8+oQqp
zf5l8V@@LAE>5VM=W5JqxJhsqB^l2m05npg2PvWU%)+DxNGJ;z)Q~HD$K@ohsS6zBL
zPmGME>m=7khTa*V+INyaCW?8a5(1$s52<>l^)0|ii6^hcLu=|?K|pye_i<Ol(`3K-
zO5Ubl@i&uRx*wXxDg&;7N`{DI#d-d(u4`I>Q4O}hJ0hz!ICUGBhuD$gbNs6B(6!b^
zMW~mUo{x2|N1QaVjQ(gD^#~vN&Y*vF=c30@Ss2SBxKZEcj<K`3y|$7j4jg|IL-bO7
zIg#ob=^A;ibjD!PO_BLD{{Y@;F@PE40QFc|^nFArx6Fl!<MBa0hkYZYW@%0i82wU9
z(_r5+3e?H?JvaB7N~Z1cVwl&udnja@6ZouL{+_#EZ`+aDFfe)UrPIAX>_<PpG=@?>
zBBS)YZ}|)Qnf)6DzqMb8oq6$^>2(b@6)$mefDZYrj2d0a+B9kz<UEExD!Wwl_2uQE
zwvtH_M)D~aq~PvSY>!cq_%xIHyF%Q;D}@Dq%?ESqy$;`KYm{Pp!RoQFewAtxK3e8Y
zr_N~je@87{37Yly{{VGj^z9}7(mc67%h&bhjtd{&LKF;+X}U-1K8ZcYw>0Pmah%p-
zZ_)@=%882)?ugUBM(xWP46X6zto;U+E+Q|vlgmBl)7pKGsi!6ET%(Ms{8f<j^{#Rh
zP~WFkg2U5s*@i9c0HZadQ_Xn2enzsmrAp1PTomI%wH>IgIu)TgE1I>C<*BT2F`CA+
zH2NQDSTq|V+^DW?7Rg2eW~@g7k&RjUsaFUaKP70<tkmw<DL?5pg^$EllMoZWY9ZZM
zJxtXgs30HuRjA`&rT+k?*{^Yf{?u!CflOogqxz}Dn-e|<hiA4K1_3l&!FH$|<W*gh
znNtAZ3NlFw#s`sKf4&bOiP1oapy7v_V=~8YfglY~8DIT8=gmQI<x26Ad!XM0A$f~#
z&n;E=i@gr>j8xYo<g)S21$4~Gj`LaP$_gvlfG3)Pj^j>o@+PAsgIPut_~(k|C;h3p
z$))H0s1S1JJyyf?=pXvj0G>BiIa;qhA$Hc<v=6xBaI5t0riGf|`nJeo*#eRL1r)rD
zHv<)0pv~{;khXh4%~-Plp+|M-OhjN1-DFeMST=s?Lj-<mMM84S*zyHBZ2(wH#@%vi
zR*lHr{{V`O95?$^i0oKrA!=JplrS6;F_TjTXH^P0rr{NdT$*x7>T(4Z{Gty~04n3<
zOCH5<mm;}9#^=sWIgxlcG>L|Xw%6r)`ld~U$K5_O+ROA!7pXyQ2tgZeax!XeN=Xv9
z1BJt9f7cZFhU0@s6;*P-%9j9qv+|<a@C1jt9i-x$jih+ZD>GvR)6z386n9FSU51A&
zSwh7B093Fbc>=c-P0S4ivKAwssuU7Ap&4#gg4Gh?Vw)@S0P{;OB$TvCw?9<K%X5ri
z{nUeMi~>QT`ym(yaRl>S*9Md$7biRlX=W|g6vzaKzzh+b)AFO06$s5d44zL_E0Pic
zfyZW)rrc!r-A9H$AZbWaM<#^?kdd4NlSoyF!L9{SgI5O2k`D)}9FSo<K`+1n*Uew4
z+JapAu67N=v0C@<Sn6@<+9k!rkF=_twesGpKkqd;u9)OI6I|_Nxk%B4abrObk{B&<
z+#3Ut=Ad=|08*X>KGs5aZsmUK5omNR3IOT}Va;l^i=%ZCGpPYZWdzZ@A|(NTHKEZZ
zD{JkpG51dvL|*%wh)}$J(}=j+l^^3CC_5tij!r<LC!L|UY`Eu~Q5ax-vjO~S8~GVB
z2Rvq$#_ksRu*v#0RjKM~9oXZJfTfe5nV(Y6A-D!kKNUwKg6AWOvGo<g+)NvzRNII8
ziLA4bQYN=onstpvNjMelev8xA!%B@p;oM}`ntBIL{pPN&Mp8a&+&w#JZ!cqo7l1`@
zeN$0OY3My8Pk%qNZ|EH?BxdSW<n@}_BLGMug45z#dt`}5FesSc4TcrtvSr^ZJ#=yH
zjT0vZow(%FK^d+&C#qJyfmS(-4k=C*LGwsQ9rI0boPAJy5OF85PRn3olOx*#ky{*&
zMIM+3H-TK-AH_9yF~}WLw;baYJLD8D-~~G$9QmfP80wydO)~movxJ;u7&OueZfO~^
z*s5K7)Y?9Zh41fTOn;|$H7U!E$y8k&sVC~VIVU+4<9?z2and0&N2a4l%h5en8&dsh
z*KUc9-Bkhlt#I`G^661TwOC`@KACAy6Y^31^v`}H+^L`c09aSa_aCT!pq!HTQZ9a)
zgKu2xJpTaSP5%J#Q?E+O`(S#^Nc#D1Q1v38{{U*FQXNUiKkr{3L+ibMGnntCC-T*4
zr+%w?pHDm5Q6L@|(=STP)r$4FlC$cjYEn)<K5M}}HTvqZFpE=%88{_t*1a+6ttVW8
zUe4(WKk3gki&3M`f&AmaqYk4MZ`ms}4oLugS7c)bxfn6P?veZCRwwu_{0sh^QYgc6
zYmoCvBAo8<C_bzt?y0x=b5NcQa+N&!rDg!;owY7SNuhC`PZi2nIr^rn78SusG#@;m
z{{Um&P-6VkQy9%T<HUIwu0l583O^?<K&rSGBOO;MC-I8na6DHl91x<N((DCysPy&J
zw5jc#K@6uA@<*%eB-6FY?WK&a*Es&G>~oO3*Mxud3F+mAb=BfdABMoL=b`I8oZj2%
zoUc~Wtk`!Y$~<TUW(<qK>`^fwY1GC$@j@%8e~v)&SDu!&7dnFS4>j($q^$7yJ}9))
zH2bI-CPvt&lUD;oj^=ONl*^uTS_!nohfCh%XB8HUa~?3?#cLzT+^oqbDMrQ9^!UU@
zS}?LFMu`zmyK^q^Dbcdr&z<{6;;k*AINq(59x6UclPRIqVY9d^FT#h_S+!%j7Rru~
z-C5q~v0Xb&C?9|+*0!+Oz@bJl_d}u7xiNZ-a@j_AjEcqH0d;ijFaSK)r}~sY_V2ii
z5nfYsk$WN|g<RImSzM#fW|+$R9Cr{S&jYGRVnD>nAOut~&JkEYEPsimwLtHQPkm;s
zOk%=6ZJ}l@$m{b=(`5HAK-xghbo)?{vB=2Bnu^83Umdu{Xpr04$ZeG$X&~`LUohGv
zL%4aNEalvY8FIMlrJh7{h4_KuoiT|cDI`2D8_iT+081-%njo2XlBbM#rbi%UXxTwD
zvI;VK{1FgY7dZ1-_~h9x-1Az!VGK@L)8qA7T}~fvVIt>gtlmP)TS?M1C3$bUgHw^+
zR5NkrhqNJ-0BLXJQh*HPcTHd|eH23Lu#{cEkzVa&F&Oz{BdYLkM6pe7A8+JKax2|z
z^1x^6ynp!{sl@Dhf9+wh5x<_QLVN+mGCU6zGUIM*%Jy`THJ;+Y*Qa_jm?JI89aoxJ
zqizIp39nG}a_zQE)=Zgaj!CCON-4zDoa5@aWYYftAxHtLa!SnT;weBLYmIQEwP7Q2
zGm1>{ic)@fG{*j4ilM%2bUQp(DdRb=11n7j83v8*ruqpca54=rxXm@XuE*U8WRu|$
zMGjW{Q(b{PR}xPGk&h#aDg0@&S0vFt81q%y#j@Ohv##Y7Y7TQwl|ft)oY!;HGs-KD
z(MDJ%W#sgplRIRx;MHBvrR-yyXu~M#wG&yL`BoripB0L2JF-vRdSCS%QdIjhtWriT
z{WER61_KAhPjBhVMFn<(KJi+H)3U^pX=AbpkaJZ(QpA<e-rS#)EV>P}PFn*N)9AJb
z2WNf-YE7Ds#V73J&mdJF>hbXrmLJKKO&-Nmud~HUwl;7e_Td1JIITFfg?s}@_R$Ps
z0ji&?O)F7DdkOh75<zYM0H|RbzVT4Dn`~Fy5e|FewM_&*QER_%7~mkq73$J`qz_>(
zjHH%Os9mw~Nj{$u3d<iS@mis4ACwi%Y@7{)kHuE~Wv5hz_6(uZ)lNd={i#;QCtykf
z!>%h*ZBd8u6tP;yBvY_b%hx%mp#GcfmA0B}j8rr~6HlAd=)~*=LFW~sQM3R!6xQ8b
zjGniulXU40utVs{Kc=KIle;6uO&*(Z5_=xs2eVpa2OMUbAt3WcKDDZf-C_11_@I3<
z*jn2AV~Qs{a%+b;$)-pEY$?rir;+4uB#RQR2THg+9McH=(u|S?N$fr|nlZ%kw(-Q9
zlzU_&jDy`ZfzC}3w&aZDQ(6*Fbnio%{{S8V?#JvL<n}4N4ydNLIN;Mox$<e3r|KUY
zLGHj6xHO0JMH_LR=_IxrbDEFSbMwG`=%1Y$Ou5RA>cynn84by*D+!(%0*nmzS1TZB
z_c+ac+79A*5)*Pk#&PvaEAEdWxuNIT9G>Xp8gIG3nwP-_T)s{eV;%lzH)2D0sU+N7
zobgc;-g-4#Tm-L`a7%Yk9Fx^gbUs{lP;T*AA7dTSuFw2ZW{~qhgT^yOSxfCqj5`N3
zD)owVY!$Oj7f!%^JNjLz4MWqh5ZPtm*0>Yy4cviV1NuMeWzzLjwVm+<ha8&v5gr+l
zWs3zEabA-SML4F6Q;j+nMv6nh=D26c%`Vkd&fMq!02JND2q5OJLK2Oj40dW&-s5VH
zssQEA?YxSaWZX7^ikCqgxe=3r-8>wq`>5lLlYnYQftSy8wu4NSc>tdkDRdxlP$IJS
zJE!g2{Jhdtkeb;HrLb^3RBqWM5=#y%l(FC(Q;5JMj%Y3&gpVW){Zz_E&_KyF(xYd6
z(!;p0Rpg2{YRObe${6hn&2(g=U>>QGN`2fh$AevfM*ZLIK`*irmzH1Vas@ser4H^7
ziiJy#sq(uQ2N>fNYr-KUB>^hugViH4mkaew*mncEoV!UN^51mTPQXZoUC1qf1#)uX
zR18r2aK{Fvj|04ln@M33Ng4PA86IjfS0n4qHZ;o&HVrwKYi#WO(NRfoOBC%63Z5&9
zm2CJl))?S+De_3$6cN=%$dMZY8zk2jz{waCgqArqN$WjfG`%883xOdRQA;_fM%d9?
zogQcU)#@*LZ~9~sd{_Bk*O9qBuUV^KP|G#mqb$<7W@DUHX5=GiIIbQ^xyiO{OKPGA
z&ipHPQe>oi6rOvgKHb<K%kHHTE^t?$CaVn#Y(Y47AY!y$o{%aP&TBTRQF0h(HGQB+
zr5;9M#T4j;@=nmnyC(<5Hu7I}3ugols7deR5(Xd@6<MlY$?t;^%AW#*nAA%x*@G>d
zW~lWW)M7|tNv7)8$J+`>1o*0Fp97w1nPjn&8+$pC!Ol%X(93h56vuTflU)h-E))+W
zRWf5G$?E?Argn=So%@ZrEya6>>Ai-;YqwwOytmQTqCGa+5HMH@_is&Gt*(<2W0Jhr
zkM&I4zsc>rFAYV03sH>c6(>h0x@=0!GCCF6=Pk`}*GFlRs{%zi_XE!r26^J7Q@hVq
z6s^#XBZGh`bL4eM;Q`Jow~e?QP`7-GUq=SqX;&cQJX26);e6A|ka6aszR1M{j*Tk@
zIBJX>9%?}$JQ|8i%N3@CC&})ko_Ouxd1Y{jqa>3~kgRCZIRRIaPm1~5_2>0L%(7^j
zJlj=%GCH2?PMb|VMATx6bLWN_IY_qsRsCm<!KKsmMh_^+G6U6o`RWf-YP!wCOMQ7H
zrH@68Q{7xV(lfgjVsc5L$**Cf^!!?Q@U8uxPh09)Gs>3;xzU?>V9oyknzYklGTjh4
z0<+pkkk5tBHRzs^(q>>~DUj6qiiNOgB;`m7TSK0>s2<Hh&f48gpuWKBx%(9a`Y==_
zmle)g4y_oGZ?bNx9Y!*-mhp<z9VSPRxEu<g^;{C$+Of_BUyfHKiZZ>hW?5!n#|O=5
zy(8*t-4^;e?Wc9xK_flZMP%gE@ID*5>q{JG8j|4Q<IOB`-4=bP`eW-We^KdZ(l8eQ
z42;&<aM|2z<L}ZhQB9_62^Y9RG3zz;Z>KdF^(!=xACVl_hxI)d>GFJ64EEX`PwH_g
zc`SxQV;oenl41&=W67pS4sa>CImL2gYST7%Ol~pFD-4YHT=@r)#V;+5y-;Z`1{!w(
zm8oK5jFDVABh4UY5s{HbG1&K5A0m_4&lJTZQm#q)S26MhGk3`-Qb}4=BnoCp@rrr^
zd7~ac#bP_Guj+o69;xYDq$(K3g_gAM!($XSr3jl&o+HR)BmV#uWG3M>{($0~X!x4*
ze0Ng8jinfhx%8FEx7A^0YyxO+TSNPAQ(r;`+(>G>NSprg1D=l+^qe_8%t~Kq`QEc0
z%#w-ix|P6|1yz@ZTBwXYoS}CXR~f23H&JOMjxGLi$?;lihPGXbPFSx7lgZ0z(H@&~
zi{EUMgIfJMKt{n>3yEGi1hI_lJmR&wOv`Z;Q^MTwxKkCSMu}1~GJFcB)#QxY$sjlj
zQ)?HdC{<%PEIF)?s4t#7SA`Bo-`zqrd;nf=yay~o=CHcenYX@t9m6%c(hTz3^K8fH
z)*scA%9@+yO0YF%7s-A*x&dTT<7qpOkE$}>JSpAtVbxYO%Q0CB;lAjoZlwco9G^9*
zGT_uFYcXzqsyjsusUsodJc^U!EwIVj-hVY6i4oogbGIHo>60O@vXzog@-_#Gk);yM
z$^gfMRh#|8xoK8Ht&rSP*h9>LRD#$iiiAj!wsIKMGS3i%sRfvGnyvR4q%5S2P;7+S
zwb-5}48I{%5~9xo2L4_s``0Eml!~a1>319tm^GeinBcItw8aR)6&&+&c+E+ANqz0v
zs`;b=#%NyvYK<46+EeNXOiRw;n)llQkfisD@DD>YjjluN{{SMxHS`9QrvN_(73BW_
z$SLH3*3f>&9IKWXG)aVQ%?$`9Y<*G0FkDvy4mC9<(Y{WoOE)UR2aMOMdP#rnQ2mPX
z`zY};splrWU(+kH-Y`C^jj2^77F_=TZKC%aR|;?gl4$@Zj}@9ophHWZE4J4KKUAtR
zzKLjbQ3pBADS&S7x-+%0L@zzpYe}cYml{oSQ#nd3fW)9uEGm1c<Qy7}daV-DV~moa
zRNF%uH7#B3B{-<famFfspC2v76Lb3`5vVke66ZLnQ}al~6U{HNiNm1om5oFh;8MB_
z;}tAPnq;IeRksc(!ZwhOO|ln_SoMl>#Jg!ZH76pSMlIbDx6u<u4~)}HV;xZfkcvAa
zTq15D_Q4c9(ExLbHyGxbD(?ofYH_JSrP%P5Fg=O4K5KyE_|muvJLZ@i*9GdMkK)a0
zH^~gJmwb*fQUt)krvi7=oq?tIp#DLp(H_tT6y2FTRH=++qbKA@IHaCv#-%|?^e4CG
zl~e*brQAyQNW9}6)o(KXC^hy<&Bz9t*{&cS%^^N19oHhERf>-4Ciyi;4n;<IG>%TI
zz{zqy18)MGk+*@(J0or>t&WzRt~df83htBoqFhrgz){HNq>$I3&|%q!pC(MQxeWt~
zW<FIY2X1O6Cp-%1I#g7SJW>uv)pLIuMLbik$TXjoBb<ujK2(e_DK3yt%<QtZeATQ4
z-q0M?N!{7*i?p4JY|b%XN`$L}&$LY@cHs9>tAK=gu9`qbLFS>}JI6HbkVfY`;-X`;
zV4Tz4i5*lK=RMNd2<92_)du-y;8E<wxW*_cMjYVzswTM#8l#SDk0Sz;s^Bszu$-oy
z=ZfMn-8cXRK!#dK@v_K`f~O$Ywtkm-_9>u`Ow=UW<Aq{t!y#k01W{2<BrLBR6=BFC
zx*A;X6Z{n9f|2$FatDkuw&h{L6(m3eAY!}^(4VQ7I(bW7Oqn4ZZayp6bU#vQdbC1I
zTa?Ki6J2=ajzwvioLqY^qe3uO{psUA?^wtFX_o96f0!fjPLfT|0x3BBQ{C_==Hrzl
zQ`2$5V$_j^+lJw(%*><=aX~);B|_bvsJnZ1mLnnY)@W#gk}}+Rt5>*ztinVv!?TK~
zB%0|AkP5HM80MyE!lf{<;g^Hvk)+<(Cz_Vo2xbZg$GVa{MTY+XRY$azz~+%MWh%!Q
zt8Fny9i@)(l4@B}Gz;yL*%>s&9pvQG)O<!bG%SLn0ze&~x>*}x>v5(!l^LmmH~<h1
zXz)Q5@^@pOs!Xo@sKBKJZYp>pn~Y~Ciey4U5aEVF^GhZaWO5BKo#+B^X-i>3p2u`3
zgovAfU~ok^fCfqCnz>~-@kn#+0gR0IMLJ}z1uD!74hP*cEJo64!Op^ms)3vq?*gN3
zwnV8CT)M*va&fd|n(-ghZF%(#SJ{n;iZhDaex~}3bo&q5LnrxPgO955+uMv1?eb>k
zxq7VD_M=uPc`5a<#_SZ}nyV@@RG*$`txn=!a4{JbTRg-_8oBO8!7?|=Mg~PkB#X#i
z=y7xl@k*g&3`1=+yMsXqJ`@AaYU0X8j@;mYF<IDukvYyNyJ$5Fx7lwCoc<{#lDir(
zZ=k8}nSlz~=7yg2_TxAruB<&9tK49)_QCG1t$$9@xw*SJ^I0dX#~v)x4IW7=qs^|S
z%M#DJglV|!SF*+Wd!wMk$-1XMr}_{B<C@O(_|baw{EYDCU{7>jjyLL1uX$l!!~X#0
z??!Te)Be=kf75FSZqjIHU{vQAq<*1|svbU{ku=SBp{>NXR&kNQ0==r-1W=gZ3i9tq
z*`<!58_M4W09U3#eQ7B8IIkzKZgWi@%hS?~DTQT$_?!xOIb0qMBtcnoo@<*Vek-2S
zO3mB~0SA-CD;$3libI85;*ftW#+C8F2^io3OCB;e^-+>Z{8Es>(qA?T36RE{N_R~R
z*(^;&PUFa@D(8Y~$2;gvv@Ubcn&Ia?({Z)Hr?AUs@k&N{x9h*F{{Z}+^wZnh$VJ4%
z9r&-1H5<8ZZXRh^v#}(TUbFuI)RwZ>-l{gL*+_=mSB^+|uV?7me{TYt?VeNCwHvbg
zYosvpXstTU?=BWK2L$6a3^AEyR31%wPo;DKZDWxm%K`~C)yt7%iN?i^<dE$f(K4dM
z>V$^moL8!Pf79O0sv-fLb5|aZjt}~B$2>!UR_PK%Nsr>S#m$yee4UI?jy1tjbaNQ~
zLaOid$X&2pW~cR!sVy|SVy02<9tKTS`eyI<<9*8!zxcIPwbhoXt0B3tNK~mDeb<@(
zr=UnN891+FzqVvkpPG0zfc4Ik9o4(xdBHVq2~^W!=UbrCJWWka8K~}JXl@=h;HjmJ
zxvu<Oo_VTe&WCi?*U-ot7-3&kewXUIlH8a0$N;aBEzTS;@N4K#(!0ie7T!$qrntVf
zjXY{cqx2k)bfA3*SQDJ&RBUj5G&O|AYdD+9S||>FM+UrP{#K7nl?WJ~#%apIX{>)d
zQ#S#eRZX-SvPU`OaZLl9=ZcOg42(k#DrLq<sRpug7Pjy=cQp9ho~ez(=Nx^~$Nagg
zW5WYn5)fGDibW(oDN6uyPc;~Pwn?iUAyRCSh~JZ4uriU34KpJr%|1B-FwF?n@<yF-
ze1-bmY_`6%xd<`6i8YJTzx$OW{{YQzfBJ~{`q|Gw=Df}uhDQV*tLPq^E!t?F7u920
zi5rV;>2i*lt*k7QTSm=|*sn9uwQ?>aNq>nvn)F>Iqnb$eKg5nJON(8cJgaI7j@3#!
zWaWnxPo|}w%2RIYNY8Y#G*;JWuKxhat}SG>C`({xjMOM)ez7}Aak#nKJPM@LpqAn^
zkR7TIUv*=4V_U`nx2|YSe(ZZNLlW(Bd{JDIDVnV&7^2Zb-~txBOV(2~y6wOi!D{vM
zB#`=Xw>QWoc!s|reMRIAmMzU$iFVBxxd)SUafM+=LN`F6NX=KXw1G>uaorPbBBO>@
z$g7hs3J&POPmj8qG?HnIjgN@q6b!Pn%ai<1nkLRiQV<`BJ=1{GX^gT!NEvW3iWSS3
zVY>uU**n6!qVwHFbC-Sjq7kdPztn#;j!J^SjCE1T?hcP0Y4I-g*g2@!K(!$!wSeCm
zr&TJ<RY}0ft9!&~)wdohmFIHpwXhEcs++K)X|_pik;_#a#H@rKYUV$RgU~fusYSAF
z>(f;>GcNrG(*FS0?fs*JxMseI)AB;@JmZ@AztG}V^#!m-!QLzB9W_qH4c<AgFYEsR
zz6V#+{{UkRwg=tFqc;-ZHAM_z8#(5exk1fwBHk$f0BqgFm|d?I3;zJ?3iWSJpYTWh
zSCrbH`?TlCuT{`N{k&v-R~uc<RYj}z7uoL=gY#T~*B&^ma=yw%4T4W~G$%Y7ADUgn
zat<o&8QwOV7E!U&C`oggm`E55P;xmvnsvMUuxm~YYFVm0CJAG>+Y2qmDTDD!PDd2g
zKZ@+RT#6DDn&upMq;Bh*s#nc~<j0yvrBg_9NCJc66i*}6khK^aiOoIu;<*NR6`?kg
zLjFdO2Q<DZBpXgEfdjEsslClGotzrxIi$$kaZPG(a-+d3k=Wz9j~tK>bmDlZ*E_RS
z<dSW0GC;GY)*_?F)e&|wH+iTO@rv?#%qkh$@NUN|jf)!qNUmVG@0#O<?wHgR+#;gT
z)o#V$^-XkO-D0>?i<bUJG!u-~OM-H`5OG|s&(W@6Ht=aMaYZK=NSqHN$)saSdIL0s
zaxqHdPJkdhaZMz*7^xcr08+0c;8m*|{kAURJaJEjH!!A?fNFb1{{U8M-5wuvDvRhD
zCAKz6=M=0suKxg4anG9dF^Wo&hWR-`BNWUX*zr#k!hTfkB#{u3fr^X+ihHo?kQxv7
z1$0C~-CZH#oZPiGPAPmcADWXe3&5dZCx0gbinv3&AP_$^8OS95Yv~;`fEZA(Bb?M{
zDso0@cu06fM>>(kSkMS$eE7vRP@J68<Xy|hVxhy2mS_-Aa8KP0a6Vh8h8bMvnq=|j
zI!U4+Mj(y_a-E|zm^r1*P%*@o=9ZK&0~n+PeN-VVPlJQzr}51Qz2=MHsK?b^je(8c
zXv-Z=^2Sj1*A9ez9w-;4qgAn!T?*Bk{Uh~5U9bw0OYR`8W|#WbhzIU13lZkLO|o-Q
z^H%<=BJwN66X<w9S+s|J(%Z7s*FUW~F3cslIQ-Ym?oK(TgG()TODD4v-)?_gEmWUs
z&Ck_WP5R$>Nf29=&3K?=nzzt2_q?1j2VkWAW@&L@_M(qs^zZ5~sdb$~C}S8#Jd9Vk
zX;8>*Qd!UW3W96PzeoKtv4MRocnkb;JFi%0DTNi%!@p<AluECG%HJ%JfGM{C97v1_
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
GKmXZ^2xo2p

literal 0
HcmV?d00001

diff --git a/modules/gpu/app/nv_perf_test/im2_1280x800.jpg b/modules/gpu/app/nv_perf_test/im2_1280x800.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ae49640a957d5a1bc26e0b0add1ee65a3c2a7bbb
GIT binary patch
literal 143366
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
H?H~WyoW3dq

literal 0
HcmV?d00001

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
new file mode 100644
index 000000000..0acde0c6b
--- /dev/null
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -0,0 +1,285 @@
+#include <cstdio>
+#define HAVE_CUDA 1
+#include <opencv2/core/core.hpp>
+#include <opencv2/gpu/gpu.hpp>
+#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/video/video.hpp>
+#include <opencv2/ts/ts.hpp>
+#include <opencv2/ts/ts_perf.hpp>
+
+static void printOsInfo()
+{
+#if defined _WIN32
+#   if defined _WIN64
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Windows x64.\n[----------]\n"); fflush(stdout);
+#   else
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Windows x32.\n[----------]\n"); fflush(stdout);
+#   endif
+#elif defined linux
+#   if defined _LP64
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Linux x64.\n[----------]\n"); fflush(stdout);
+#   else
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Linux x32.\n[----------]\n"); fflush(stdout);
+#   endif
+#elif defined __APPLE__
+#   if defined _LP64
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Apple x64.\n[----------]\n"); fflush(stdout);
+#   else
+        printf("[----------]\n[ GPU INFO ] \tRun on OS Apple x32.\n[----------]\n"); fflush(stdout);
+#   endif
+#endif
+}
+
+static void printCudaInfo()
+{
+    const int deviceCount = cv::gpu::getCudaEnabledDeviceCount();
+
+    printf("[----------]\n"); fflush(stdout);
+    printf("[ GPU INFO ] \tCUDA device count:: %d.\n", deviceCount); fflush(stdout);
+    printf("[----------]\n"); fflush(stdout);
+
+    for (int i = 0; i < deviceCount; ++i)
+    {
+        cv::gpu::DeviceInfo info(i);
+
+        printf("[----------]\n"); fflush(stdout);
+        printf("[ DEVICE   ] \t# %d %s.\n", i, info.name().c_str()); fflush(stdout);
+        printf("[          ] \tCompute capability: %d.%d\n", info.majorVersion(), info.minorVersion()); fflush(stdout);
+        printf("[          ] \tMulti Processor Count:  %d\n", info.multiProcessorCount()); fflush(stdout);
+        printf("[          ] \tTotal memory: %d Mb\n", static_cast<int>(static_cast<int>(info.totalMemory() / 1024.0) / 1024.0)); fflush(stdout);
+        printf("[          ] \tFree  memory: %d Mb\n", static_cast<int>(static_cast<int>(info.freeMemory()  / 1024.0) / 1024.0)); fflush(stdout);
+        if (!info.isCompatible())
+            printf("[ GPU INFO ] \tThis device is NOT compatible with current GPU module build\n");
+        printf("[----------]\n"); fflush(stdout);
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    printOsInfo();
+    printCudaInfo();
+
+    perf::Regression::Init("nv_perf_test");
+    perf::TestBase::Init(argc, argv);
+    testing::InitGoogleTest(&argc, argv);
+
+    return RUN_ALL_TESTS();
+}
+
+//////////////////////////////////////////////////////////
+// Tests
+
+#define DEF_PARAM_TEST(name, ...) typedef ::perf::TestBaseWithParam< std::tr1::tuple< __VA_ARGS__ > > name
+#define DEF_PARAM_TEST_1(name, param_type) typedef ::perf::TestBaseWithParam< param_type > name
+
+DEF_PARAM_TEST_1(Depth, perf::MatDepth);
+
+PERF_TEST_P(Depth, GoodFeaturesToTrack, testing::Values(CV_8U, CV_16U))
+{
+    declare.time(60);
+
+    const int depth = GetParam();
+    const int maxCorners = 5000;
+    const double qualityLevel = 0.05;
+    const int minDistance = 5;
+    const int blockSize = 3;
+    const bool useHarrisDetector = true;
+    const double k = 0.05;
+
+    const std::string fileName = "im1_1280x800.jpg";
+
+    cv::Mat src = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
+    if (src.empty())
+        FAIL() << "Unable to load source image [" << fileName << "]";
+
+    if (depth != CV_8U)
+        src.convertTo(src, depth);
+
+    cv::Mat mask(src.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Rect(0, 0, 100, 100)).setTo(cv::Scalar::all(0));
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
+
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_pts;
+
+        d_detector(d_src, d_pts, d_mask);
+
+        TEST_CYCLE()
+        {
+            d_detector(d_src, d_pts, d_mask);
+        }
+    }
+    else
+    {
+        cv::Mat pts;
+
+        cv::goodFeaturesToTrack(src, pts, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k);
+
+        TEST_CYCLE()
+        {
+            cv::goodFeaturesToTrack(src, pts, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k);
+        }
+    }
+
+    SANITY_CHECK(0);
+}
+
+DEF_PARAM_TEST(Depth_GraySource, perf::MatDepth, bool);
+
+PERF_TEST_P(Depth_GraySource, PyrLKOpticalFlowSparse, testing::Combine(testing::Values(CV_8U, CV_16U), testing::Bool()))
+{
+    declare.time(60);
+
+    const int depth = std::tr1::get<0>(GetParam());
+    const bool graySource = std::tr1::get<1>(GetParam());
+
+    // PyrLK params
+    const cv::Size winSize(15, 15);
+    const int maxLevel = 5;
+    const cv::TermCriteria criteria(cv::TermCriteria::COUNT + cv::TermCriteria::EPS, 30, 0.01);
+
+    // GoodFeaturesToTrack params
+    const int maxCorners = 5000;
+    const double qualityLevel = 0.05;
+    const int minDistance = 5;
+    const int blockSize = 3;
+    const bool useHarrisDetector = true;
+    const double k = 0.05;
+
+    const std::string fileName1 = "im1_1280x800.jpg";
+    const std::string fileName2 = "im2_1280x800.jpg";
+
+    cv::Mat src1 = cv::imread(fileName1, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    if (src1.empty())
+        FAIL() << "Unable to load source image [" << fileName1 << "]";
+
+    cv::Mat src2 = cv::imread(fileName2, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    if (src2.empty())
+        FAIL() << "Unable to load source image [" << fileName2 << "]";
+
+    cv::Mat gray_src;
+    if (graySource)
+        gray_src = src1;
+    else
+        cv::cvtColor(src1, gray_src, cv::COLOR_BGR2GRAY);
+
+    cv::Mat pts;
+    cv::goodFeaturesToTrack(gray_src, pts, maxCorners, qualityLevel, minDistance, cv::noArray(), blockSize, useHarrisDetector, k);
+
+    if (depth != CV_8U)
+    {
+        src1.convertTo(src1, depth);
+        src2.convertTo(src2, depth);
+    }
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
+
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = winSize;
+        d_pyrLK.maxLevel = maxLevel;
+        d_pyrLK.iters = criteria.maxCount;
+        d_pyrLK.useInitialFlow = false;
+
+        d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+
+        TEST_CYCLE()
+        {
+            d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+        }
+    }
+    else
+    {
+        cv::Mat nextPts;
+        cv::Mat status;
+
+        cv::calcOpticalFlowPyrLK(src1, src2, pts, nextPts, status, cv::noArray(), winSize, maxLevel, criteria);
+
+        TEST_CYCLE()
+        {
+            cv::calcOpticalFlowPyrLK(src1, src2, pts, nextPts, status, cv::noArray(), winSize, maxLevel, criteria);
+        }
+    }
+
+    SANITY_CHECK(0);
+}
+
+DEF_PARAM_TEST_1(Depth, perf::MatDepth);
+
+PERF_TEST_P(Depth, FarnebackOpticalFlow, testing::Values(CV_8U, CV_16U))
+{
+    declare.time(60);
+
+    const int depth = GetParam();
+
+    const double pyrScale = 0.5;
+    const int numLevels = 6;
+    const int winSize = 7;
+    const int numIters = 15;
+    const int polyN = 7;
+    const double polySigma = 1.5;
+    const int flags = cv::OPTFLOW_USE_INITIAL_FLOW;
+
+    const std::string fileName1 = "im1_1280x800.jpg";
+    const std::string fileName2 = "im2_1280x800.jpg";
+
+    cv::Mat src1 = cv::imread(fileName1, cv::IMREAD_GRAYSCALE);
+    if (src1.empty())
+        FAIL() << "Unable to load source image [" << fileName1 << "]";
+
+    cv::Mat src2 = cv::imread(fileName2, cv::IMREAD_GRAYSCALE);
+    if (src2.empty())
+        FAIL() << "Unable to load source image [" << fileName2 << "]";
+
+    if (depth != CV_8U)
+    {
+        src1.convertTo(src1, depth);
+        src2.convertTo(src2, depth);
+    }
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
+        cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
+
+        cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.numLevels = numLevels;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
+
+        d_farneback(d_src1, d_src2, d_u, d_v);
+
+        TEST_CYCLE()
+        {
+            d_farneback(d_src1, d_src2, d_u, d_v);
+        }
+    }
+    else
+    {
+        cv::Mat flow(src1.size(), CV_32FC2, cv::Scalar::all(0));
+
+        cv::calcOpticalFlowFarneback(src1, src2, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
+
+        TEST_CYCLE()
+        {
+            cv::calcOpticalFlowFarneback(src1, src2, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
+        }
+    }
+
+    SANITY_CHECK(0);
+}

From a6dc6f72b38c067dbbe2ac9c40f9fbd62e8b085c Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 6 Dec 2012 15:11:13 +0400
Subject: [PATCH 121/155] gpu::calcOpticalFlowBM

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   7 +
 modules/gpu/perf/perf_video.cpp         |  68 ++++++++
 modules/gpu/src/cuda/optflowbm.cu       | 170 ++++++++++++++++++++
 modules/gpu/src/optflowbm.cpp           | 205 ++++++++++++++++++++++++
 modules/gpu/test/test_video.cpp         |  54 +++++++
 5 files changed, 504 insertions(+)
 create mode 100644 modules/gpu/src/cuda/optflowbm.cu
 create mode 100644 modules/gpu/src/optflowbm.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 7f7da9e9f..6a477dc38 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -2097,6 +2097,13 @@ private:
 };
 
 
+//! Calculates optical flow for 2 images using block matching algorithm */
+CV_EXPORTS void calcOpticalFlowBM(const GpuMat& prev, const GpuMat& curr,
+                                  Size block_size, Size shift_size, Size max_range, bool use_previous,
+                                  GpuMat& velx, GpuMat& vely, GpuMat& buf,
+                                  Stream& stream = Stream::Null());
+
+
 //! Interpolate frames (images) using provided optical flow (displacement field).
 //! frame0   - frame 0 (32-bit floating point images, single channel)
 //! frame1   - frame 1 (the same type and size)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index b228580fd..5a598ebe5 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -444,6 +444,74 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
     }
 }
 
+//////////////////////////////////////////////////////
+// OpticalFlowBM
+
+void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
+                       cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
+                       cv::Mat& velx, cv::Mat& vely)
+{
+    cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
+
+    velx.create(sz, CV_32FC1);
+    vely.create(sz, CV_32FC1);
+
+    CvMat cvprev = prev;
+    CvMat cvcurr = curr;
+
+    CvMat cvvelx = velx;
+    CvMat cvvely = vely;
+
+    cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
+}
+
+PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
+    Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
+{
+    declare.time(400);
+
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
+
+        cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+        TEST_CYCLE()
+        {
+            cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+        }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
+    }
+    else
+    {
+        cv::Mat velx, vely;
+
+        calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+
+        TEST_CYCLE()
+        {
+            calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+        }
+
+        CPU_SANITY_CHECK(velx);
+        CPU_SANITY_CHECK(vely);
+    }
+}
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 
diff --git a/modules/gpu/src/cuda/optflowbm.cu b/modules/gpu/src/cuda/optflowbm.cu
new file mode 100644
index 000000000..e924170fc
--- /dev/null
+++ b/modules/gpu/src/cuda/optflowbm.cu
@@ -0,0 +1,170 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or bpied warranties, including, but not limited to, the bpied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#if !defined CUDA_DISABLER
+
+#include "opencv2/gpu/device/common.hpp"
+#include "opencv2/gpu/device/limits.hpp"
+
+using namespace cv::gpu;
+using namespace cv::gpu::device;
+
+namespace
+{
+    texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_prev(false, cudaFilterModePoint, cudaAddressModeClamp);
+    texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_curr(false, cudaFilterModePoint, cudaAddressModeClamp);
+
+    __device__ int cmpBlocks(int X1, int Y1, int X2, int Y2, int2 blockSize)
+    {
+        int s = 0;
+
+        for (int y = 0; y < blockSize.y; ++y)
+        {
+            for (int x = 0; x < blockSize.x; ++x)
+                s += ::abs(tex2D(tex_prev, X1 + x, Y1 + y) - tex2D(tex_curr, X2 + x, Y2 + y));
+        }
+
+        return s;
+    }
+
+    __global__ void calcOptFlowBM(PtrStepSzf velx, PtrStepf vely, const int2 blockSize, const int2 shiftSize, const bool usePrevious,
+                                  const int maxX, const int maxY, const int acceptLevel, const int escapeLevel,
+                                  const short2* ss, const int ssCount)
+    {
+        const int j = blockIdx.x * blockDim.x + threadIdx.x;
+        const int i = blockIdx.y * blockDim.y + threadIdx.y;
+
+        if (i >= velx.rows || j >= velx.cols)
+            return;
+
+        const int X1 = j * shiftSize.x;
+        const int Y1 = i * shiftSize.y;
+
+        const int offX = usePrevious ? __float2int_rn(velx(i, j)) : 0;
+        const int offY = usePrevious ? __float2int_rn(vely(i, j)) : 0;
+
+        int X2 = X1 + offX;
+        int Y2 = Y1 + offY;
+
+        int dist = numeric_limits<int>::max();
+
+        if (0 <= X2 && X2 <= maxX && 0 <= Y2 && Y2 <= maxY)
+            dist = cmpBlocks(X1, Y1, X2, Y2, blockSize);
+
+        int countMin = 1;
+        int sumx = offX;
+        int sumy = offY;
+
+        if (dist > acceptLevel)
+        {
+            // do brute-force search
+            for (int k = 0; k < ssCount; ++k)
+            {
+                const short2 ssVal = ss[k];
+
+                const int dx = offX + ssVal.x;
+                const int dy = offY + ssVal.y;
+
+                X2 = X1 + dx;
+                Y2 = Y1 + dy;
+
+                if (0 <= X2 && X2 <= maxX && 0 <= Y2 && Y2 <= maxY)
+                {
+                    const int tmpDist = cmpBlocks(X1, Y1, X2, Y2, blockSize);
+                    if (tmpDist < acceptLevel)
+                    {
+                        sumx = dx;
+                        sumy = dy;
+                        countMin = 1;
+                        break;
+                    }
+
+                    if (tmpDist < dist)
+                    {
+                        dist = tmpDist;
+                        sumx = dx;
+                        sumy = dy;
+                        countMin = 1;
+                    }
+                    else if (tmpDist == dist)
+                    {
+                        sumx += dx;
+                        sumy += dy;
+                        countMin++;
+                    }
+                }
+            }
+
+            if (dist > escapeLevel)
+            {
+                sumx = offX;
+                sumy = offY;
+                countMin = 1;
+            }
+        }
+
+        velx(i, j) = static_cast<float>(sumx) / countMin;
+        vely(i, j) = static_cast<float>(sumy) / countMin;
+    }
+}
+
+namespace optflowbm
+{
+    void calc(PtrStepSzb prev, PtrStepSzb curr, PtrStepSzf velx, PtrStepSzf vely, int2 blockSize, int2 shiftSize, bool usePrevious,
+              int maxX, int maxY, int acceptLevel, int escapeLevel, const short2* ss, int ssCount, cudaStream_t stream)
+    {
+        bindTexture(&tex_prev, prev);
+        bindTexture(&tex_curr, curr);
+
+        const dim3 block(32, 8);
+        const dim3 grid(divUp(velx.cols, block.x), divUp(vely.rows, block.y));
+
+        calcOptFlowBM<<<grid, block, 0, stream>>>(velx, vely, blockSize, shiftSize, usePrevious,
+                                                  maxX, maxY, acceptLevel,  escapeLevel, ss, ssCount);
+        cudaSafeCall( cudaGetLastError() );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+}
+
+#endif // !defined CUDA_DISABLER
diff --git a/modules/gpu/src/optflowbm.cpp b/modules/gpu/src/optflowbm.cpp
new file mode 100644
index 000000000..ec2f0f9f9
--- /dev/null
+++ b/modules/gpu/src/optflowbm.cpp
@@ -0,0 +1,205 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "precomp.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+#if !defined HAVE_CUDA || defined(CUDA_DISABLER)
+
+void cv::gpu::calcOpticalFlowBM(const GpuMat&, const GpuMat&, Size, Size, Size, bool, GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
+
+#else // HAVE_CUDA
+
+namespace optflowbm
+{
+    void calc(PtrStepSzb prev, PtrStepSzb curr, PtrStepSzf velx, PtrStepSzf vely, int2 blockSize, int2 shiftSize, bool usePrevious,
+              int maxX, int maxY, int acceptLevel, int escapeLevel, const short2* ss, int ssCount, cudaStream_t stream);
+}
+
+void cv::gpu::calcOpticalFlowBM(const GpuMat& prev, const GpuMat& curr, Size blockSize, Size shiftSize, Size maxRange, bool usePrevious, GpuMat& velx, GpuMat& vely, GpuMat& buf, Stream& st)
+{
+    CV_Assert( prev.type() == CV_8UC1 );
+    CV_Assert( curr.size() == prev.size() && curr.type() == prev.type() );
+
+    const Size velSize((prev.cols - blockSize.width + shiftSize.width) / shiftSize.width,
+                       (prev.rows - blockSize.height + shiftSize.height) / shiftSize.height);
+
+    velx.create(velSize, CV_32FC1);
+    vely.create(velSize, CV_32FC1);
+
+    // scanning scheme coordinates
+    vector<short2> ss((2 * maxRange.width + 1) * (2 * maxRange.height + 1));
+    int ssCount = 0;
+
+    // Calculate scanning scheme
+    const int minCount = std::min(maxRange.width, maxRange.height);
+
+    // use spiral search pattern
+    //
+    //     9 10 11 12
+    //     8  1  2 13
+    //     7  *  3 14
+    //     6  5  4 15
+    //... 20 19 18 17
+    //
+
+    for (int i = 0; i < minCount; ++i)
+    {
+        // four cycles along sides
+        int x = -i - 1, y = x;
+
+        // upper side
+        for (int j = -i; j <= i + 1; ++j, ++ssCount)
+        {
+            ss[ssCount].x = ++x;
+            ss[ssCount].y = y;
+        }
+
+        // right side
+        for (int j = -i; j <= i + 1; ++j, ++ssCount)
+        {
+            ss[ssCount].x = x;
+            ss[ssCount].y = ++y;
+        }
+
+        // bottom side
+        for (int j = -i; j <= i + 1; ++j, ++ssCount)
+        {
+            ss[ssCount].x = --x;
+            ss[ssCount].y = y;
+        }
+
+        // left side
+        for (int j = -i; j <= i + 1; ++j, ++ssCount)
+        {
+            ss[ssCount].x = x;
+            ss[ssCount].y = --y;
+        }
+    }
+
+    // the rest part
+    if (maxRange.width < maxRange.height)
+    {
+        const int xleft = -minCount;
+
+        // cycle by neighbor rings
+        for (int i = minCount; i < maxRange.height; ++i)
+        {
+            // two cycles by x
+            int y = -(i + 1);
+            int x = xleft;
+
+            // upper side
+            for (int j = -maxRange.width; j <= maxRange.width; ++j, ++ssCount, ++x)
+            {
+                ss[ssCount].x = x;
+                ss[ssCount].y = y;
+            }
+
+            x = xleft;
+            y = -y;
+
+            // bottom side
+            for (int j = -maxRange.width; j <= maxRange.width; ++j, ++ssCount, ++x)
+            {
+                ss[ssCount].x = x;
+                ss[ssCount].y = y;
+            }
+        }
+    }
+    else if (maxRange.width > maxRange.height)
+    {
+        const int yupper = -minCount;
+
+        // cycle by neighbor rings
+        for (int i = minCount; i < maxRange.width; ++i)
+        {
+            // two cycles by y
+            int x = -(i + 1);
+            int y = yupper;
+
+            // left side
+            for (int j = -maxRange.height; j <= maxRange.height; ++j, ++ssCount, ++y)
+            {
+                ss[ssCount].x = x;
+                ss[ssCount].y = y;
+            }
+
+            y = yupper;
+            x = -x;
+
+            // right side
+            for (int j = -maxRange.height; j <= maxRange.height; ++j, ++ssCount, ++y)
+            {
+                ss[ssCount].x = x;
+                ss[ssCount].y = y;
+            }
+        }
+    }
+
+    const cudaStream_t stream = StreamAccessor::getStream(st);
+
+    ensureSizeIsEnough(1, ssCount, CV_16SC2, buf);
+    if (stream == 0)
+        cudaSafeCall( cudaMemcpy(buf.data, &ss[0], ssCount * sizeof(short2), cudaMemcpyHostToDevice) );
+    else
+        cudaSafeCall( cudaMemcpyAsync(buf.data, &ss[0], ssCount * sizeof(short2), cudaMemcpyHostToDevice, stream) );
+
+    const int maxX = prev.cols - blockSize.width;
+    const int maxY = prev.rows - blockSize.height;
+
+    const int SMALL_DIFF = 2;
+    const int BIG_DIFF = 128;
+
+    const int blSize = blockSize.area();
+    const int acceptLevel = blSize * SMALL_DIFF;
+    const int escapeLevel = blSize * BIG_DIFF;
+
+    optflowbm::calc(prev, curr, velx, vely,
+                    make_int2(blockSize.width, blockSize.height), make_int2(shiftSize.width, shiftSize.height), usePrevious,
+                    maxX, maxY, acceptLevel, escapeLevel, buf.ptr<short2>(), ssCount, stream);
+}
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 2d44af1a7..eb69721bd 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -444,6 +444,60 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
     ALL_DEVICES,
     WHOLE_SUBMAT));
 
+//////////////////////////////////////////////////////
+// OpticalFlowBM
+
+void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
+                       cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
+                       cv::Mat& velx, cv::Mat& vely)
+{
+    cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
+
+    velx.create(sz, CV_32FC1);
+    vely.create(sz, CV_32FC1);
+
+    CvMat cvprev = prev;
+    CvMat cvcurr = curr;
+
+    CvMat cvvelx = velx;
+    CvMat cvvely = vely;
+
+    cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
+}
+
+struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+};
+
+TEST_P(OpticalFlowBM, Accuracy)
+{
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
+
+    cv::gpu::GpuMat d_velx, d_vely, buf;
+    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+                               block_size, shift_size, max_range, false,
+                               d_velx, d_vely, buf);
+
+    cv::Mat velx, vely;
+    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+
+    EXPECT_MAT_NEAR(velx, d_velx, 0);
+    EXPECT_MAT_NEAR(vely, d_vely, 0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 

From aad76090ce96967f07cb87f8b7152b23190496d8 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 6 Dec 2012 15:14:20 +0400
Subject: [PATCH 122/155] gpu::HoughLinesP

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   5 ++
 modules/gpu/perf/perf_imgproc.cpp       |  66 +++++++++++++++
 modules/gpu/src/cuda/canny.cu           |   6 +-
 modules/gpu/src/cuda/hough.cu           | 104 +++++++++++++++++++++++-
 modules/gpu/src/hough.cpp               |  38 +++++++++
 modules/gpu/src/imgproc.cpp             |   1 +
 samples/gpu/houghlines.cpp              |  75 +++++++++++++++++
 7 files changed, 291 insertions(+), 4 deletions(-)
 create mode 100644 samples/gpu/houghlines.cpp

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 6a477dc38..2bbfe532f 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -847,6 +847,11 @@ CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, float rho, float th
 CV_EXPORTS void HoughLines(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int threshold, bool doSort = false, int maxLines = 4096);
 CV_EXPORTS void HoughLinesDownload(const GpuMat& d_lines, OutputArray h_lines, OutputArray h_votes = noArray());
 
+//! HoughLinesP
+
+//! finds line segments in the black-n-white image using probabalistic Hough transform
+CV_EXPORTS void HoughLinesP(const GpuMat& image, GpuMat& lines, CannyBuf& cannyBuf, int minLineLength, int maxLineGap, int maxLines = 4096);
+
 //! HoughCircles
 
 struct HoughCirclesBuf
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index a9c8b5984..b8feab83a 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -1706,6 +1706,16 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
 }
 
 namespace {
+    struct Vec4iComparator
+    {
+        bool operator()(const cv::Vec4i& a, const cv::Vec4i b) const
+        {
+            if (a[0] != b[0]) return a[0] < b[0];
+            else if(a[1] != b[1]) return a[1] < b[1];
+            else if(a[2] != b[2]) return a[2] < b[2];
+            else return a[3] < b[3];
+        }
+    };
     struct Vec3fComparator
     {
         bool operator()(const cv::Vec3f& a, const cv::Vec3f b) const
@@ -1784,6 +1794,62 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
     }
 }
 
+//////////////////////////////////////////////////////////////////////
+// HoughLinesP
+
+DEF_PARAM_TEST_1(Image, std::string);
+
+PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "stitching/a1.png"))
+{
+    declare.time(30.0);
+
+    std::string fileName = getDataPath(GetParam());
+
+    const double rho = 1.0f;
+    const double theta = CV_PI / 180.0;
+    const int threshold = 100;
+    const int minLineLenght = 50;
+    const int maxLineGap = 5;
+
+    cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::CannyBuf d_buf;
+
+        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
+            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+        }
+
+        cv::Mat h_lines(d_lines);
+        cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
+        cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
+        std::sort(begin, end, Vec4iComparator());
+        SANITY_CHECK(h_lines);
+    }
+    else
+    {
+        cv::Mat mask;
+        cv::Canny(image, mask, 50, 100);
+
+        std::vector<cv::Vec4i> lines;
+        cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
+            cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+        }
+
+        std::sort(lines.begin(), lines.end(), Vec4iComparator());
+        SANITY_CHECK(lines);
+    }
+}
+
 //////////////////////////////////////////////////////////////////////
 // HoughCircles
 
diff --git a/modules/gpu/src/cuda/canny.cu b/modules/gpu/src/cuda/canny.cu
index b08a61c83..ae9cac831 100644
--- a/modules/gpu/src/cuda/canny.cu
+++ b/modules/gpu/src/cuda/canny.cu
@@ -177,7 +177,7 @@ namespace
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        if (x >= dx.cols || y >= dx.rows)
+        if (x == 0 || x >= dx.cols - 1 || y == 0 || y >= dx.rows - 1)
             return;
 
         int dxVal = dx(y, x);
@@ -378,7 +378,7 @@ namespace
             pos.x += c_dx[threadIdx.x];
             pos.y += c_dy[threadIdx.x];
 
-            if (pos.x > 0 && pos.x <= map.cols && pos.y > 0 && pos.y <= map.rows && map(pos.y, pos.x) == 1)
+            if (pos.x > 0 && pos.x < map.cols && pos.y > 0 && pos.y < map.rows && map(pos.y, pos.x) == 1)
             {
                 map(pos.y, pos.x) = 2;
 
@@ -410,7 +410,7 @@ namespace
                 pos.x += c_dx[threadIdx.x & 7];
                 pos.y += c_dy[threadIdx.x & 7];
 
-                if (pos.x > 0 && pos.x <= map.cols && pos.y > 0 && pos.y <= map.rows && map(pos.y, pos.x) == 1)
+                if (pos.x > 0 && pos.x < map.cols && pos.y > 0 && pos.y < map.rows && map(pos.y, pos.x) == 1)
                 {
                     map(pos.y, pos.x) = 2;
 
diff --git a/modules/gpu/src/cuda/hough.cu b/modules/gpu/src/cuda/hough.cu
index ee4d02591..4835e3568 100644
--- a/modules/gpu/src/cuda/hough.cu
+++ b/modules/gpu/src/cuda/hough.cu
@@ -291,6 +291,108 @@ namespace cv { namespace gpu { namespace device
             return totalCount;
         }
 
+        ////////////////////////////////////////////////////////////////////////
+        // houghLinesProbabilistic
+
+        texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_mask(false, cudaFilterModePoint, cudaAddressModeClamp);
+
+        __global__ void houghLinesProbabilistic(const PtrStepSzi Dx, const PtrStepi Dy,
+                                                int4* out, const int maxSize,
+                                                const int lineGap, const int lineLength)
+        {
+            const int SHIFT = 10;
+
+            const int x = blockIdx.x * blockDim.x + threadIdx.x;
+            const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+            if (x >= Dx.cols || y >= Dx.rows || tex2D(tex_mask, x, y) == 0)
+                return;
+
+            const int dx = Dx(y, x);
+            const int dy = Dy(y, x);
+
+            if (dx == 0 && dy == 0)
+                return;
+
+            const int vx = dy;
+            const int vy = -dx;
+
+            const float mag = ::sqrtf(vx * vx + vy * vy);
+
+            const int x0 = x << SHIFT;
+            const int y0 = y << SHIFT;
+
+            int sx = __float2int_rn((vx << SHIFT) / mag);
+            int sy = __float2int_rn((vy << SHIFT) / mag);
+
+            int2 line_end[2] = {make_int2(x,y), make_int2(x,y)};
+
+            for (int k = 0; k < 2; ++k)
+            {
+                int gap = 0;
+                int x1 = x0 + sx;
+                int y1 = y0 + sy;
+
+                for (;; x1 += sx, y1 += sy)
+                {
+                    const int x2 = x1 >> SHIFT;
+                    const int y2 = y1 >> SHIFT;
+
+                    if (x2 < 0 || x2 >= Dx.cols || y2 < 0 || y2 >= Dx.rows)
+                        break;
+
+                    if (tex2D(tex_mask, x2, y2))
+                    {
+                        gap = 0;
+                        line_end[k].x = x2;
+                        line_end[k].y = y2;
+                    }
+                    else if(++gap > lineGap)
+                        break;
+                }
+
+                sx = -sx;
+                sy = -sy;
+            }
+
+            const bool good_line = ::abs(line_end[1].x - line_end[0].x) >= lineLength ||
+                                   ::abs(line_end[1].y - line_end[0].y) >= lineLength;
+
+            if (good_line)
+            {
+                const int ind = ::atomicAdd(&g_counter, 1);
+                if (ind < maxSize)
+                    out[ind] = make_int4(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+            }
+        }
+
+        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi Dx, PtrStepSzi Dy,
+                                        int4* out, int maxSize,
+                                        int lineGap, int lineLength)
+        {
+            void* counterPtr;
+            cudaSafeCall( cudaGetSymbolAddress(&counterPtr, g_counter) );
+
+            cudaSafeCall( cudaMemset(counterPtr, 0, sizeof(int)) );
+
+            const dim3 block(32, 8);
+            const dim3 grid(divUp(mask.cols, block.x), divUp(mask.rows, block.y));
+
+            bindTexture(&tex_mask, mask);
+
+            houghLinesProbabilistic<<<grid, block>>>(Dx, Dy, out, maxSize, lineGap, lineLength);
+            cudaSafeCall( cudaGetLastError() );
+
+            cudaSafeCall( cudaDeviceSynchronize() );
+
+            int totalCount;
+            cudaSafeCall( cudaMemcpy(&totalCount, counterPtr, sizeof(int), cudaMemcpyDeviceToHost) );
+
+            totalCount = ::min(totalCount, maxSize);
+
+            return totalCount;
+        }
+
         ////////////////////////////////////////////////////////////////////////
         // circlesAccumCenters
 
@@ -1509,4 +1611,4 @@ namespace cv { namespace gpu { namespace device
 }}}
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/hough.cpp b/modules/gpu/src/hough.cpp
index 6e2170d11..daeb62536 100644
--- a/modules/gpu/src/hough.cpp
+++ b/modules/gpu/src/hough.cpp
@@ -52,6 +52,8 @@ void cv::gpu::HoughLines(const GpuMat&, GpuMat&, float, float, int, bool, int) {
 void cv::gpu::HoughLines(const GpuMat&, GpuMat&, HoughLinesBuf&, float, float, int, bool, int) { throw_nogpu(); }
 void cv::gpu::HoughLinesDownload(const GpuMat&, OutputArray, OutputArray) { throw_nogpu(); }
 
+void cv::gpu::HoughLinesP(const GpuMat&, GpuMat&, CannyBuf&, int, int, int) { throw_nogpu(); }
+
 void cv::gpu::HoughCircles(const GpuMat&, GpuMat&, int, float, float, int, int, int, int, int) { throw_nogpu(); }
 void cv::gpu::HoughCircles(const GpuMat&, GpuMat&, HoughCirclesBuf&, int, float, float, int, int, int, int, int) { throw_nogpu(); }
 void cv::gpu::HoughCirclesDownload(const GpuMat&, OutputArray) { throw_nogpu(); }
@@ -155,6 +157,42 @@ void cv::gpu::HoughLinesDownload(const GpuMat& d_lines, OutputArray h_lines_, Ou
     }
 }
 
+//////////////////////////////////////////////////////////
+// HoughLinesP
+
+namespace cv { namespace gpu { namespace device
+{
+    namespace hough
+    {
+        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi Dx, PtrStepSzi Dy,
+                                        int4* out, int maxSize,
+                                        int lineGap, int lineLength);
+    }
+}}}
+
+void cv::gpu::HoughLinesP(const GpuMat& image, GpuMat& lines, CannyBuf& cannyBuf, int minLineLength, int maxLineGap, int maxLines)
+{
+    using namespace cv::gpu::device::hough;
+
+    CV_Assert( image.type() == CV_8UC1 );
+    CV_Assert( image.cols < std::numeric_limits<unsigned short>::max() );
+    CV_Assert( image.rows < std::numeric_limits<unsigned short>::max() );
+
+    GpuMat mask;
+    Canny(image, cannyBuf, mask, 50, 100);
+
+    ensureSizeIsEnough(1, maxLines, CV_32SC4, lines);
+
+    int linesCount = houghLinesProbabilistic_gpu(mask, cannyBuf.dx, cannyBuf.dy,
+                                                 lines.ptr<int4>(), maxLines,
+                                                 maxLineGap, minLineLength);
+
+    if (linesCount > 0)
+        lines.cols = linesCount;
+    else
+        lines.release();
+}
+
 //////////////////////////////////////////////////////////
 // HoughCircles
 
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index b216de874..2c14f67df 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -1484,6 +1484,7 @@ namespace
     {
         using namespace canny;
 
+        buf.map.setTo(Scalar::all(0));
         calcMap(dx, dy, buf.mag, buf.map, low_thresh, high_thresh);
 
         edgesHysteresisLocal(buf.map, buf.st1.ptr<ushort2>());
diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp
new file mode 100644
index 000000000..e9bb96915
--- /dev/null
+++ b/samples/gpu/houghlines.cpp
@@ -0,0 +1,75 @@
+#include <cmath>
+#include <iostream>
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/gpu/gpu.hpp"
+
+using namespace std;
+using namespace cv;
+using namespace cv::gpu;
+
+static void help()
+{
+    cout << "This program demonstrates line finding with the Hough transform." << endl;
+    cout << "Usage:" << endl;
+    cout << "./gpu-example-houghlines <image_name>, Default is pic1.png\n" << endl;
+}
+
+int main(int argc, const char* argv[])
+{
+    const string filename = argc >= 2 ? argv[1] : "pic1.png";
+
+    Mat src = imread(filename, IMREAD_GRAYSCALE);
+    if (src.empty())
+    {
+        help();
+        cout << "can not open " << filename << endl;
+        return -1;
+    }
+
+    Mat mask;
+    Canny(src, mask, 50, 200, 3);
+
+    Mat dst_cpu;
+    cvtColor(mask, dst_cpu, CV_GRAY2BGR);
+    Mat dst_gpu = dst_cpu.clone();
+
+    vector<Vec4i> lines_cpu;
+    HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 50, 5);
+    cout << lines_cpu.size() << endl;
+
+    for (size_t i = 0; i < lines_cpu.size(); ++i)
+    {
+        Vec4i l = lines_cpu[i];
+        line(dst_cpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, CV_AA);
+    }
+
+    GpuMat d_src(src);
+    GpuMat d_lines;
+    CannyBuf d_buf;
+    gpu::HoughLinesP(d_src, d_lines, d_buf, 50, 5);
+    vector<Vec4i> lines_gpu;
+    if (!d_lines.empty())
+    {
+        lines_gpu.resize(d_lines.cols);
+        Mat h_lines(1, d_lines.cols, CV_32SC4, &lines_gpu[0]);
+        d_lines.download(h_lines);
+    }
+    cout << lines_gpu.size() << endl;
+
+    for (size_t i = 0; i < lines_gpu.size(); ++i)
+    {
+        Vec4i l = lines_gpu[i];
+        line(dst_gpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, CV_AA);
+    }
+
+    imshow("source", src);
+    imshow("detected lines [CPU]", dst_cpu);
+    imshow("detected lines [GPU]", dst_gpu);
+    waitKey();
+
+    return 0;
+}
+

From 0d880479f076e053ca3d359bf8dcce1c56a777dc Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 6 Dec 2012 16:00:47 +0400
Subject: [PATCH 123/155] updated nv perf test script (added opticalFlowBM and
 HoughLinesP)

---
 modules/gpu/app/nv_perf_test/main.cpp | 215 ++++++++++++++++++++++----
 1 file changed, 183 insertions(+), 32 deletions(-)

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
index 0acde0c6b..3d457e492 100644
--- a/modules/gpu/app/nv_perf_test/main.cpp
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -4,6 +4,7 @@
 #include <opencv2/gpu/gpu.hpp>
 #include <opencv2/highgui/highgui.hpp>
 #include <opencv2/video/video.hpp>
+#include <opencv2/legacy/legacy.hpp>
 #include <opencv2/ts/ts.hpp>
 #include <opencv2/ts/ts_perf.hpp>
 
@@ -66,19 +67,75 @@ int main(int argc, char* argv[])
     return RUN_ALL_TESTS();
 }
 
-//////////////////////////////////////////////////////////
-// Tests
-
 #define DEF_PARAM_TEST(name, ...) typedef ::perf::TestBaseWithParam< std::tr1::tuple< __VA_ARGS__ > > name
 #define DEF_PARAM_TEST_1(name, param_type) typedef ::perf::TestBaseWithParam< param_type > name
 
-DEF_PARAM_TEST_1(Depth, perf::MatDepth);
+//////////////////////////////////////////////////////////
+// HoughLinesP
 
-PERF_TEST_P(Depth, GoodFeaturesToTrack, testing::Values(CV_8U, CV_16U))
+DEF_PARAM_TEST_1(Image, std::string);
+
+PERF_TEST_P(Image, HoughLinesP,
+            testing::Values(std::string("im1_1280x800.jpg")))
+{
+    declare.time(30.0);
+
+    std::string fileName = GetParam();
+
+    const double rho = 1.0;
+    const double theta = 1.0;
+    const int threshold = 40;
+    const int minLineLenght = 20;
+    const int maxLineGap = 5;
+
+    cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::CannyBuf d_buf;
+
+        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
+            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+        }
+    }
+    else
+    {
+        cv::Mat mask;
+        cv::Canny(image, mask, 50, 100);
+
+        std::vector<cv::Vec4i> lines;
+        cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
+            cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+        }
+    }
+
+    SANITY_CHECK(0);
+}
+
+//////////////////////////////////////////////////////////
+// GoodFeaturesToTrack
+
+DEF_PARAM_TEST(Image_Depth, std::string, perf::MatDepth);
+
+PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
+            testing::Combine(
+                testing::Values(std::string("im1_1280x800.jpg")),
+                testing::Values(CV_8U, CV_16U)
+                ))
 {
     declare.time(60);
 
-    const int depth = GetParam();
+    const std::string fileName = std::tr1::get<0>(GetParam());
+    const int depth = std::tr1::get<1>(GetParam());
+
     const int maxCorners = 5000;
     const double qualityLevel = 0.05;
     const int minDistance = 5;
@@ -86,8 +143,6 @@ PERF_TEST_P(Depth, GoodFeaturesToTrack, testing::Values(CV_8U, CV_16U))
     const bool useHarrisDetector = true;
     const double k = 0.05;
 
-    const std::string fileName = "im1_1280x800.jpg";
-
     cv::Mat src = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
     if (src.empty())
         FAIL() << "Unable to load source image [" << fileName << "]";
@@ -115,6 +170,9 @@ PERF_TEST_P(Depth, GoodFeaturesToTrack, testing::Values(CV_8U, CV_16U))
     }
     else
     {
+        if (depth != CV_8U)
+            FAIL() << "Unsupported depth";
+
         cv::Mat pts;
 
         cv::goodFeaturesToTrack(src, pts, maxCorners, qualityLevel, minDistance, mask, blockSize, useHarrisDetector, k);
@@ -128,14 +186,25 @@ PERF_TEST_P(Depth, GoodFeaturesToTrack, testing::Values(CV_8U, CV_16U))
     SANITY_CHECK(0);
 }
 
-DEF_PARAM_TEST(Depth_GraySource, perf::MatDepth, bool);
+//////////////////////////////////////////////////////////
+// OpticalFlowPyrLKSparse
 
-PERF_TEST_P(Depth_GraySource, PyrLKOpticalFlowSparse, testing::Combine(testing::Values(CV_8U, CV_16U), testing::Bool()))
+typedef std::pair<std::string, std::string> string_pair;
+
+DEF_PARAM_TEST(ImagePair_Depth_GraySource, string_pair, perf::MatDepth, bool);
+
+PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
+            testing::Combine(
+                testing::Values(string_pair("im1_1280x800.jpg", "im2_1280x800.jpg")),
+                testing::Values(CV_8U, CV_16U),
+                testing::Bool()
+                ))
 {
     declare.time(60);
 
-    const int depth = std::tr1::get<0>(GetParam());
-    const bool graySource = std::tr1::get<1>(GetParam());
+    const string_pair fileNames = std::tr1::get<0>(GetParam());
+    const int depth = std::tr1::get<1>(GetParam());
+    const bool graySource = std::tr1::get<2>(GetParam());
 
     // PyrLK params
     const cv::Size winSize(15, 15);
@@ -150,16 +219,13 @@ PERF_TEST_P(Depth_GraySource, PyrLKOpticalFlowSparse, testing::Combine(testing::
     const bool useHarrisDetector = true;
     const double k = 0.05;
 
-    const std::string fileName1 = "im1_1280x800.jpg";
-    const std::string fileName2 = "im2_1280x800.jpg";
-
-    cv::Mat src1 = cv::imread(fileName1, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    cv::Mat src1 = cv::imread(fileNames.first, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
     if (src1.empty())
-        FAIL() << "Unable to load source image [" << fileName1 << "]";
+        FAIL() << "Unable to load source image [" << fileNames.first << "]";
 
-    cv::Mat src2 = cv::imread(fileName2, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    cv::Mat src2 = cv::imread(fileNames.second, graySource ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
     if (src2.empty())
-        FAIL() << "Unable to load source image [" << fileName2 << "]";
+        FAIL() << "Unable to load source image [" << fileNames.second << "]";
 
     cv::Mat gray_src;
     if (graySource)
@@ -199,6 +265,9 @@ PERF_TEST_P(Depth_GraySource, PyrLKOpticalFlowSparse, testing::Combine(testing::
     }
     else
     {
+        if (depth != CV_8U)
+            FAIL() << "Unsupported depth";
+
         cv::Mat nextPts;
         cv::Mat status;
 
@@ -213,13 +282,21 @@ PERF_TEST_P(Depth_GraySource, PyrLKOpticalFlowSparse, testing::Combine(testing::
     SANITY_CHECK(0);
 }
 
-DEF_PARAM_TEST_1(Depth, perf::MatDepth);
+//////////////////////////////////////////////////////////
+// OpticalFlowFarneback
 
-PERF_TEST_P(Depth, FarnebackOpticalFlow, testing::Values(CV_8U, CV_16U))
+DEF_PARAM_TEST(ImagePair_Depth, string_pair, perf::MatDepth);
+
+PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
+            testing::Combine(
+                testing::Values(string_pair("im1_1280x800.jpg", "im2_1280x800.jpg")),
+                testing::Values(CV_8U, CV_16U)
+                ))
 {
-    declare.time(60);
+    declare.time(500);
 
-    const int depth = GetParam();
+    const string_pair fileNames = std::tr1::get<0>(GetParam());
+    const int depth = std::tr1::get<1>(GetParam());
 
     const double pyrScale = 0.5;
     const int numLevels = 6;
@@ -229,16 +306,13 @@ PERF_TEST_P(Depth, FarnebackOpticalFlow, testing::Values(CV_8U, CV_16U))
     const double polySigma = 1.5;
     const int flags = cv::OPTFLOW_USE_INITIAL_FLOW;
 
-    const std::string fileName1 = "im1_1280x800.jpg";
-    const std::string fileName2 = "im2_1280x800.jpg";
-
-    cv::Mat src1 = cv::imread(fileName1, cv::IMREAD_GRAYSCALE);
+    cv::Mat src1 = cv::imread(fileNames.first, cv::IMREAD_GRAYSCALE);
     if (src1.empty())
-        FAIL() << "Unable to load source image [" << fileName1 << "]";
+        FAIL() << "Unable to load source image [" << fileNames.first << "]";
 
-    cv::Mat src2 = cv::imread(fileName2, cv::IMREAD_GRAYSCALE);
+    cv::Mat src2 = cv::imread(fileNames.second, cv::IMREAD_GRAYSCALE);
     if (src2.empty())
-        FAIL() << "Unable to load source image [" << fileName2 << "]";
+        FAIL() << "Unable to load source image [" << fileNames.second << "]";
 
     if (depth != CV_8U)
     {
@@ -264,18 +338,21 @@ PERF_TEST_P(Depth, FarnebackOpticalFlow, testing::Values(CV_8U, CV_16U))
 
         d_farneback(d_src1, d_src2, d_u, d_v);
 
-        TEST_CYCLE()
+        TEST_CYCLE_N(10)
         {
             d_farneback(d_src1, d_src2, d_u, d_v);
         }
     }
     else
     {
+        if (depth != CV_8U)
+            FAIL() << "Unsupported depth";
+
         cv::Mat flow(src1.size(), CV_32FC2, cv::Scalar::all(0));
 
         cv::calcOpticalFlowFarneback(src1, src2, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
 
-        TEST_CYCLE()
+        TEST_CYCLE_N(10)
         {
             cv::calcOpticalFlowFarneback(src1, src2, flow, pyrScale, numLevels, winSize, numIters, polyN, polySigma, flags);
         }
@@ -283,3 +360,77 @@ PERF_TEST_P(Depth, FarnebackOpticalFlow, testing::Values(CV_8U, CV_16U))
 
     SANITY_CHECK(0);
 }
+
+//////////////////////////////////////////////////////////
+// OpticalFlowBM
+
+void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
+                       cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
+                       cv::Mat& velx, cv::Mat& vely)
+{
+    cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
+
+    velx.create(sz, CV_32FC1);
+    vely.create(sz, CV_32FC1);
+
+    CvMat cvprev = prev;
+    CvMat cvcurr = curr;
+
+    CvMat cvvelx = velx;
+    CvMat cvvely = vely;
+
+    cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
+}
+
+DEF_PARAM_TEST(ImagePair_BlockSize_ShiftSize_MaxRange, string_pair, cv::Size, cv::Size, cv::Size);
+
+PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
+            testing::Combine(
+                testing::Values(string_pair("im1_1280x800.jpg", "im2_1280x800.jpg")),
+                testing::Values(cv::Size(16, 16)),
+                testing::Values(cv::Size(2, 2)),
+                testing::Values(cv::Size(16, 16))
+                ))
+{
+    declare.time(1000);
+
+    const string_pair fileNames = std::tr1::get<0>(GetParam());
+    const cv::Size block_size = std::tr1::get<1>(GetParam());
+    const cv::Size shift_size = std::tr1::get<2>(GetParam());
+    const cv::Size max_range = std::tr1::get<3>(GetParam());
+
+    cv::Mat src1 = cv::imread(fileNames.first, cv::IMREAD_GRAYSCALE);
+    if (src1.empty())
+        FAIL() << "Unable to load source image [" << fileNames.first << "]";
+
+    cv::Mat src2 = cv::imread(fileNames.second, cv::IMREAD_GRAYSCALE);
+    if (src2.empty())
+        FAIL() << "Unable to load source image [" << fileNames.second << "]";
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
+
+        cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+        TEST_CYCLE_N(10)
+        {
+            cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+        }
+    }
+    else
+    {
+        cv::Mat velx, vely;
+
+        calcOpticalFlowBM(src1, src2, block_size, shift_size, max_range, false, velx, vely);
+
+        TEST_CYCLE_N(10)
+        {
+            calcOpticalFlowBM(src1, src2, block_size, shift_size, max_range, false, velx, vely);
+        }
+    }
+
+    SANITY_CHECK(0);
+}

From c6263eb25332170ad43d550cffbb0648c0db1d0f Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 7 Dec 2012 14:03:23 +0400
Subject: [PATCH 124/155] fixed build with CUDA and witout OpenGL

---
 modules/core/src/gl_core_3_1.cpp    | 171 +++++++++++++++-------------
 modules/core/src/opengl_interop.cpp |  29 ++---
 2 files changed, 104 insertions(+), 96 deletions(-)

diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp
index 97c11d2e7..716d02b89 100644
--- a/modules/core/src/gl_core_3_1.cpp
+++ b/modules/core/src/gl_core_3_1.cpp
@@ -1,94 +1,111 @@
-#include "cvconfig.h"
-
-#ifdef HAVE_OPENGL
-
 #include <string>
+#include <sstream>
+#include "cvconfig.h"
+#include "opencv2/core/core.hpp"
 #include "gl_core_3_1.hpp"
 
-#if defined(__APPLE__)
-    #include <mach-o/dyld.h>
+#ifdef HAVE_OPENGL
+    #if defined(__APPLE__)
+        #include <mach-o/dyld.h>
 
-    static void* AppleGLGetProcAddress (const GLubyte *name)
-    {
-        static const struct mach_header* image = 0;
-        if (!image)
-            image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
-
-        // prepend a '_' for the Unix C symbol mangling convention
-        std::string symbolName = "_";
-        symbolName += std::string((const char*)name);
-
-        NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0;
-
-        return symbol ? NSAddressOfSymbol(symbol) : 0;
-    }
-#endif // __APPLE__
-
-#if defined(__sgi) || defined (__sun)
-    #include <dlfcn.h>
-    #include <stdio.h>
-
-    static void* SunGetProcAddress (const GLubyte* name)
-    {
-        typedef void* (func_t*)(const GLubyte*);
-
-        static void* h = 0;
-        static func_t gpa = 0;
-
-        if (!h)
+        static void* AppleGLGetProcAddress (const char* name)
         {
-            h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL);
+            static const struct mach_header* image = 0;
+            if (!image)
+                image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR);
+
+            // prepend a '_' for the Unix C symbol mangling convention
+            std::string symbolName = "_";
+            symbolName += std::string(name);
+
+            NSSymbol symbol = image ? NSLookupSymbolInImage(image, &symbolName[0], NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : 0;
+
+            return symbol ? NSAddressOfSymbol(symbol) : 0;
+        }
+    #endif // __APPLE__
+
+    #if defined(__sgi) || defined (__sun)
+        #include <dlfcn.h>
+        #include <stdio.h>
+
+        static void* SunGetProcAddress (const char* name)
+        {
+            typedef void* (func_t*)(const GLubyte*);
+
+            static void* h = 0;
+            static func_t gpa = 0;
+
             if (!h)
+            {
+                h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL);
+                if (!h)
+                    return 0;
+                gpa = (func_t) dlsym(h, "glXGetProcAddress");
+            }
+
+            return gpa ? gpa((const GLubyte*) name) : dlsym(h, name);
+        }
+    #endif // __sgi || __sun
+
+    #if defined(_WIN32)
+        #ifdef _MSC_VER
+            #pragma warning(disable: 4055)
+            #pragma warning(disable: 4054)
+        #endif
+
+        static int TestPointer(const PROC pTest)
+        {
+            if(!pTest)
                 return 0;
-            gpa = (func_t) dlsym(h, "glXGetProcAddress");
+
+            ptrdiff_t iTest = (ptrdiff_t) pTest;
+
+            if (iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1)
+                return 0;
+
+            return 1;
         }
 
-        return gpa ? gpa(name) : dlsym(h, (const char*) name);
-    }
-#endif /* __sgi || __sun */
+        static PROC WinGetProcAddress(const char* name)
+        {
+            PROC pFunc = wglGetProcAddress((LPCSTR) name);
+            if (TestPointer(pFunc))
+                return pFunc;
 
-#if defined(_WIN32)
-    #ifdef _MSC_VER
-        #pragma warning(disable: 4055)
-        #pragma warning(disable: 4054)
+            HMODULE glMod = GetModuleHandleA("OpenGL32.dll");
+            return (PROC) GetProcAddress(glMod, (LPCSTR) name);
+        }
+    #endif // _WIN32
+
+    #if defined(_WIN32)
+        #define CV_GL_GET_PROC_ADDRESS(name) WinGetProcAddress(name)
+    #elif defined(__APPLE__)
+        #define CV_GL_GET_PROC_ADDRESS(name) AppleGLGetProcAddress(name)
+    #elif defined(__sgi) || defined(__sun)
+        #define CV_GL_GET_PROC_ADDRESS(name) SunGetProcAddress(name)
+    #else // GLX
+        #include <GL/glx.h>
+
+        #define CV_GL_GET_PROC_ADDRESS(name) (*glXGetProcAddressARB)((const GLubyte*) name)
     #endif
 
-    static int TestPointer(const PROC pTest)
+    static void* IntGetProcAddress(const char* name)
     {
-        if(!pTest)
-            return 0;
-
-        ptrdiff_t iTest = (ptrdiff_t) pTest;
-
-        if (iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1)
-            return 0;
-
-        return 1;
+        void* func = CV_GL_GET_PROC_ADDRESS(name);
+        if (!func)
+        {
+            std::ostringstream msg;
+            msg << "Can't load OpenGL extension [" << name << "]";
+            CV_Error(CV_OpenGlApiCallError, msg.str());
+        }
+        return func;
     }
-
-    static PROC WinGetProcAddress(const char* name)
-    {
-        PROC pFunc = wglGetProcAddress((LPCSTR) name);
-        if (TestPointer(pFunc))
-            return pFunc;
-
-        HMODULE glMod = GetModuleHandleA("OpenGL32.dll");
-        return (PROC) GetProcAddress(glMod, (LPCSTR) name);
-    }
-
-    #define IntGetProcAddress(name) WinGetProcAddress(name)
 #else
-    #if defined(__APPLE__)
-        #define IntGetProcAddress(name) AppleGLGetProcAddress(name)
-    #else
-        #if defined(__sgi) || defined(__sun)
-            #define IntGetProcAddress(name) SunGetProcAddress(name)
-        #else /* GLX */
-            #include <GL/glx.h>
-
-            #define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*) name)
-        #endif
-    #endif
+    static void* IntGetProcAddress(const char*)
+    {
+        CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
+        return 0;
+    }
 #endif
 
 namespace gl
@@ -2699,5 +2716,3 @@ namespace gl
 
     InitializeVariables g_initVariables;
 }
-
-#endif
diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index 64739792a..86c85589d 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -44,13 +44,11 @@
 #include "opencv2/core/opengl_interop.hpp"
 #include "opencv2/core/gpumat.hpp"
 
-#ifdef HAVE_OPENGL
-    #include "gl_core_3_1.hpp"
+#include "gl_core_3_1.hpp"
 
-    #ifdef HAVE_CUDA
-        #include <cuda_runtime.h>
-        #include <cuda_gl_interop.h>
-    #endif
+#ifdef HAVE_CUDA
+    #include <cuda_runtime.h>
+    #include <cuda_gl_interop.h>
 #endif
 
 using namespace std;
@@ -59,6 +57,12 @@ using namespace cv::gpu;
 
 namespace
 {
+    #ifndef HAVE_OPENGL
+        void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); }
+    #else
+        void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); }
+    #endif
+
     #ifndef HAVE_CUDA
         void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); }
     #else
@@ -76,12 +80,6 @@ namespace
                 cv::gpu::error(cudaGetErrorString(err), file, line, func);
         }
     #endif
-
-    #ifndef HAVE_OPENGL
-        void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); }
-    #else
-        void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); }
-    #endif
 }
 
 bool cv::checkGlError(const char* file, const int line, const char* func)
@@ -145,12 +143,7 @@ void cv::gpu::setGlDevice(int device)
     (void) device;
     throw_nocuda();
 #else
-    #ifndef HAVE_OPENGL
-        (void) device;
-        throw_nogl();
-    #else
-        cudaSafeCall( cudaGLSetGLDevice(device) );
-    #endif
+    cudaSafeCall( cudaGLSetGLDevice(device) );
 #endif
 }
 

From 4102aaaf157027e3afd34721a47ed9117cfd2563 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Fri, 7 Dec 2012 14:16:18 +0400
Subject: [PATCH 125/155] fixed compilation of color.cu under windows x86

it was some bug in nvcc (it fails on this file)
---
 modules/gpu/include/opencv2/gpu/device/detail/color_detail.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/detail/color_detail.hpp b/modules/gpu/include/opencv2/gpu/device/detail/color_detail.hpp
index 981e62335..fb3bfeb9e 100644
--- a/modules/gpu/include/opencv2/gpu/device/detail/color_detail.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/detail/color_detail.hpp
@@ -807,9 +807,9 @@ namespace cv { namespace gpu { namespace device
 
         template <int bidx, typename T, typename D> static __device__ __forceinline__ void RGB2XYZConvert(const T* src, D& dst)
         {
+            dst.z = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[6] + src[1] * c_RGB2XYZ_D65i[7] + src[bidx] * c_RGB2XYZ_D65i[8], xyz_shift));
             dst.x = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[0] + src[1] * c_RGB2XYZ_D65i[1] + src[bidx] * c_RGB2XYZ_D65i[2], xyz_shift));
             dst.y = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[3] + src[1] * c_RGB2XYZ_D65i[4] + src[bidx] * c_RGB2XYZ_D65i[5], xyz_shift));
-            dst.z = saturate_cast<T>(CV_DESCALE(src[bidx^2] * c_RGB2XYZ_D65i[6] + src[1] * c_RGB2XYZ_D65i[7] + src[bidx] * c_RGB2XYZ_D65i[8], xyz_shift));
         }
 
         template <int bidx> static __device__ __forceinline__ uint RGB2XYZConvert(uint src)

From 79c3a8e03b27af87f4816e0024fa41aad3099bba Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Fri, 7 Dec 2012 16:56:17 +0400
Subject: [PATCH 126/155] fix build under win.

---
 modules/gpu/src/icf.hpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/modules/gpu/src/icf.hpp b/modules/gpu/src/icf.hpp
index 3f3449bad..e4e3f9416 100644
--- a/modules/gpu/src/icf.hpp
+++ b/modules/gpu/src/icf.hpp
@@ -56,7 +56,7 @@
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
-struct __align__(16) Octave
+struct Octave
 {
     ushort index;
     ushort stages;
@@ -68,7 +68,7 @@ struct __align__(16) Octave
     : index(i), stages(s), shrinkage(sh), size(sz), scale(sc) {}
 };
 
-struct __align__(8) Level //is actually 24 bytes
+struct Level //is actually 24 bytes
 {
     int octave;
     int step;
@@ -84,7 +84,7 @@ struct __align__(8) Level //is actually 24 bytes
     __device Level(){}
 };
 
-struct __align__(8) Node
+struct Node
 {
     uchar4 rect;
     // ushort channel;
@@ -95,12 +95,13 @@ struct __align__(8) Node
     Node(const uchar4 r, const unsigned int ch, const unsigned int t) : rect(r), threshold(t + (ch << 28)) {}
 };
 
-struct __align__(16) Detection
+struct Detection
 {
     ushort x;
     ushort y;
     ushort w;
     ushort h;
+
     float confidence;
     int kind;
 

From 5fe9bb717d93b789d27382948af166287be5b614 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 10 Dec 2012 11:05:51 +0400
Subject: [PATCH 127/155] fixed build under linux with OpenGL

---
 modules/core/src/gl_core_3_1.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp
index 716d02b89..3bc74faa1 100644
--- a/modules/core/src/gl_core_3_1.cpp
+++ b/modules/core/src/gl_core_3_1.cpp
@@ -86,12 +86,12 @@
     #else // GLX
         #include <GL/glx.h>
 
-        #define CV_GL_GET_PROC_ADDRESS(name) (*glXGetProcAddressARB)((const GLubyte*) name)
+        #define CV_GL_GET_PROC_ADDRESS(name) glXGetProcAddressARB((const GLubyte*) name)
     #endif
 
     static void* IntGetProcAddress(const char* name)
     {
-        void* func = CV_GL_GET_PROC_ADDRESS(name);
+        void* func =  (void*) CV_GL_GET_PROC_ADDRESS(name);
         if (!func)
         {
             std::ostringstream msg;

From 50946b59c14a81b52a6530d421a88dc6b1307e8c Mon Sep 17 00:00:00 2001
From: Anatoly Baksheev <no@email>
Date: Mon, 10 Dec 2012 17:36:02 +0400
Subject: [PATCH 128/155] minor device namespace refactor

---
 modules/core/include/opencv2/core/cuda_devptrs.hpp | 14 ++++++++++++++
 modules/gpu/CMakeLists.txt                         | 13 ++++---------
 modules/gpu/include/opencv2/gpu/device/common.hpp  |  8 +++++---
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/modules/core/include/opencv2/core/cuda_devptrs.hpp b/modules/core/include/opencv2/core/cuda_devptrs.hpp
index 6363e0dc4..26fc2403f 100644
--- a/modules/core/include/opencv2/core/cuda_devptrs.hpp
+++ b/modules/core/include/opencv2/core/cuda_devptrs.hpp
@@ -152,6 +152,20 @@ namespace cv
 //#undef __CV_GPU_DEPR_BEFORE__
 //#undef __CV_GPU_DEPR_AFTER__
 
+        namespace device
+        {
+            using cv::gpu::PtrSz;
+            using cv::gpu::PtrStep;
+            using cv::gpu::PtrStepSz;
+
+            using cv::gpu::PtrStepSzb;
+            using cv::gpu::PtrStepSzf;
+            using cv::gpu::PtrStepSzi;
+
+            using cv::gpu::PtrStepb;
+            using cv::gpu::PtrStepf;
+            using cv::gpu::PtrStepi;
+        }
     }
 }
 
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 78aafcf92..1227b93a3 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -22,17 +22,14 @@ source_group("Device"         FILES ${lib_device_hdrs})
 source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
 if (HAVE_CUDA)
-  file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp")
-  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")
-  file(GLOB_RECURSE ncv_hdrs "src/nvidia/*.hpp" "src/nvidia/*.h")
-  set(ncv_files ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda})
+  file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp" "src/nvidia/*.h*")
+  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")  
+  set(ncv_files ${ncv_srcs} ${ncv_cuda})
 
   source_group("Src\\NVidia" FILES ${ncv_files})
   ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations /wd4211 /wd4201 /wd4100 /wd4505 /wd4408)
-  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-  #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-keep")
+  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")  
   #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
 
   if(MSVC)
@@ -47,8 +44,6 @@ if (HAVE_CUDA)
 
   ocv_cuda_compile(cuda_objs ${lib_cuda} ${ncv_cuda})
 
-  #CUDA_BUILD_CLEAN_TARGET()
-
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 
   if(NOT APPLE)
diff --git a/modules/gpu/include/opencv2/gpu/device/common.hpp b/modules/gpu/include/opencv2/gpu/device/common.hpp
index 141467fdc..ffe2c98b8 100644
--- a/modules/gpu/include/opencv2/gpu/device/common.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/common.hpp
@@ -85,8 +85,6 @@ static inline void ___cudaSafeCall(cudaError_t err, const char *file, const int
         cv::gpu::error(cudaGetErrorString(err), file, line, func);
 }
 
-#ifdef __CUDACC__
-
 namespace cv { namespace gpu
 {
     __host__ __device__ __forceinline__ int divUp(int total, int grain)
@@ -96,6 +94,9 @@ namespace cv { namespace gpu
 
     namespace device
     {
+        using cv::gpu::divUp;
+
+#ifdef __CUDACC__
         typedef unsigned char uchar;
         typedef unsigned short ushort;
         typedef signed char schar;
@@ -106,9 +107,10 @@ namespace cv { namespace gpu
             cudaChannelFormatDesc desc = cudaCreateChannelDesc<T>();
             cudaSafeCall( cudaBindTexture2D(0, tex, img.ptr(), &desc, img.cols, img.rows, img.step) );
         }
+#endif // __CUDACC__
     }
 }}
 
-#endif // __CUDACC__
+
 
 #endif // __OPENCV_GPU_COMMON_HPP__

From 746bc168e688bc4b357cfb2b9236b98833062ce2 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 11 Dec 2012 11:05:06 +0400
Subject: [PATCH 129/155] fixed gpu warpAffine and warpPerspective with NPP

---
 modules/gpu/src/warp.cpp | 48 ++++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

diff --git a/modules/gpu/src/warp.cpp b/modules/gpu/src/warp.cpp
index 2522c5a7b..e663b8952 100644
--- a/modules/gpu/src/warp.cpp
+++ b/modules/gpu/src/warp.cpp
@@ -143,33 +143,31 @@ namespace
     {
         typedef typename NppWarpFunc<DEPTH>::npp_t npp_t;
 
-        static void call(const cv::gpu::GpuMat& src, cv::Size wholeSize, cv::Point ofs, cv::gpu::GpuMat& dst,
-                         double coeffs[][3], cv::Size dsize, int interpolation, cudaStream_t stream)
+        static void call(const cv::gpu::GpuMat& src, cv::gpu::GpuMat& dst, double coeffs[][3], int interpolation, cudaStream_t stream)
         {
             static const int npp_inter[] = {NPPI_INTER_NN, NPPI_INTER_LINEAR, NPPI_INTER_CUBIC};
 
-            dst.create(dsize, src.type());
-            dst.setTo(cv::Scalar::all(0));
-
             NppiSize srcsz;
-            srcsz.height = wholeSize.height;
-            srcsz.width = wholeSize.width;
+            srcsz.height = src.rows;
+            srcsz.width = src.cols;
 
             NppiRect srcroi;
-            srcroi.x = ofs.x;
-            srcroi.y = ofs.y;
+            srcroi.x = 0;
+            srcroi.y = 0;
             srcroi.height = src.rows;
             srcroi.width = src.cols;
 
             NppiRect dstroi;
-            dstroi.x = dstroi.y = 0;
+            dstroi.x = 0;
+            dstroi.y = 0;
             dstroi.height = dst.rows;
             dstroi.width = dst.cols;
 
             cv::gpu::NppStreamHandler h(stream);
 
-            nppSafeCall( func((npp_t*)src.datastart, srcsz, static_cast<int>(src.step), srcroi,
-                              dst.ptr<npp_t>(), static_cast<int>(dst.step), dstroi, coeffs, npp_inter[interpolation]) );
+            nppSafeCall( func(src.ptr<npp_t>(), srcsz, static_cast<int>(src.step), srcroi,
+                              dst.ptr<npp_t>(), static_cast<int>(dst.step), dstroi, 
+                              coeffs, npp_inter[interpolation]) );
 
             if (stream == 0)
                 cudaSafeCall( cudaDeviceSynchronize() );
@@ -187,6 +185,8 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
     CV_Assert(interpolation == INTER_NEAREST || interpolation == INTER_LINEAR || interpolation == INTER_CUBIC);
     CV_Assert(borderMode == BORDER_REFLECT101 || borderMode == BORDER_REPLICATE || borderMode == BORDER_CONSTANT || borderMode == BORDER_REFLECT || borderMode == BORDER_WRAP);
 
+    dst.create(dsize, src.type());
+
     Size wholeSize;
     Point ofs;
     src.locateROI(wholeSize, ofs);
@@ -231,8 +231,7 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
         }
     };
 
-    bool useNpp = borderMode == BORDER_CONSTANT;
-    useNpp = useNpp && useNppTab[src.depth()][src.channels() - 1][interpolation];
+    bool useNpp = borderMode == BORDER_CONSTANT && ofs.x == 0 && ofs.y == 0 && useNppTab[src.depth()][src.channels() - 1][interpolation];
     #ifdef linux
         // NPP bug on float data
         useNpp = useNpp && src.depth() != CV_32F;
@@ -240,7 +239,7 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
 
     if (useNpp)
     {
-        typedef void (*func_t)(const cv::gpu::GpuMat& src, cv::Size wholeSize, cv::Point ofs, cv::gpu::GpuMat& dst, double coeffs[][3], cv::Size dsize, int flags, cudaStream_t stream);
+        typedef void (*func_t)(const cv::gpu::GpuMat& src, cv::gpu::GpuMat& dst, double coeffs[][3], int flags, cudaStream_t stream);
 
         static const func_t funcs[2][6][4] =
         {
@@ -262,6 +261,8 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
             }
         };
 
+        dst.setTo(borderValue);
+
         double coeffs[2][3];
         Mat coeffsMat(2, 3, CV_64F, (void*)coeffs);
         M.convertTo(coeffsMat, coeffsMat.type());
@@ -269,7 +270,7 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
         const func_t func = funcs[(flags & WARP_INVERSE_MAP) != 0][src.depth()][src.channels() - 1];
         CV_Assert(func != 0);
 
-        func(src, wholeSize, ofs, dst, coeffs, dsize, interpolation, StreamAccessor::getStream(s));
+        func(src, dst, coeffs, interpolation, StreamAccessor::getStream(s));
     }
     else
     {
@@ -294,8 +295,6 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
         int gpuBorderType;
         CV_Assert(tryConvertToGpuBorderType(borderMode, gpuBorderType));
 
-        dst.create(dsize, src.type());
-
         float coeffs[2 * 3];
         Mat coeffsMat(2, 3, CV_32F, (void*)coeffs);
 
@@ -329,6 +328,8 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
     CV_Assert(interpolation == INTER_NEAREST || interpolation == INTER_LINEAR || interpolation == INTER_CUBIC);
     CV_Assert(borderMode == BORDER_REFLECT101 || borderMode == BORDER_REPLICATE || borderMode == BORDER_CONSTANT || borderMode == BORDER_REFLECT || borderMode == BORDER_WRAP);
 
+    dst.create(dsize, src.type());
+
     Size wholeSize;
     Point ofs;
     src.locateROI(wholeSize, ofs);
@@ -373,8 +374,7 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
         }
     };
 
-    bool useNpp = borderMode == BORDER_CONSTANT;
-    useNpp = useNpp && useNppTab[src.depth()][src.channels() - 1][interpolation];
+    bool useNpp = borderMode == BORDER_CONSTANT && ofs.x == 0 && ofs.y == 0 && useNppTab[src.depth()][src.channels() - 1][interpolation];
     #ifdef linux
         // NPP bug on float data
         useNpp = useNpp && src.depth() != CV_32F;
@@ -382,7 +382,7 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
 
     if (useNpp)
     {
-        typedef void (*func_t)(const cv::gpu::GpuMat& src, cv::Size wholeSize, cv::Point ofs, cv::gpu::GpuMat& dst, double coeffs[][3], cv::Size dsize, int flags, cudaStream_t stream);
+        typedef void (*func_t)(const cv::gpu::GpuMat& src, cv::gpu::GpuMat& dst, double coeffs[][3], int flags, cudaStream_t stream);
 
         static const func_t funcs[2][6][4] =
         {
@@ -404,6 +404,8 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
             }
         };
 
+        dst.setTo(borderValue);
+
         double coeffs[3][3];
         Mat coeffsMat(3, 3, CV_64F, (void*)coeffs);
         M.convertTo(coeffsMat, coeffsMat.type());
@@ -411,7 +413,7 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
         const func_t func = funcs[(flags & WARP_INVERSE_MAP) != 0][src.depth()][src.channels() - 1];
         CV_Assert(func != 0);
 
-        func(src, wholeSize, ofs, dst, coeffs, dsize, interpolation, StreamAccessor::getStream(s));
+        func(src, dst, coeffs, interpolation, StreamAccessor::getStream(s));
     }
     else
     {
@@ -436,8 +438,6 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
         int gpuBorderType;
         CV_Assert(tryConvertToGpuBorderType(borderMode, gpuBorderType));
 
-        dst.create(dsize, src.type());
-
         float coeffs[3 * 3];
         Mat coeffsMat(3, 3, CV_32F, (void*)coeffs);
 

From 87e0eee92b98a16980c66414cf0b2536b0da21fc Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 11 Dec 2012 14:38:08 +0400
Subject: [PATCH 130/155] fixed remap and warp gpu tests

---
 modules/gpu/test/interpolation.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/modules/gpu/test/interpolation.hpp b/modules/gpu/test/interpolation.hpp
index f8aed1a38..8e723c5c0 100644
--- a/modules/gpu/test/interpolation.hpp
+++ b/modules/gpu/test/interpolation.hpp
@@ -42,6 +42,9 @@
 #ifndef __OPENCV_TEST_INTERPOLATION_HPP__
 #define __OPENCV_TEST_INTERPOLATION_HPP__
 
+#include "opencv2/core/core.hpp"
+#include "opencv2/imgproc/imgproc.hpp"
+
 template <typename T> T readVal(const cv::Mat& src, int y, int x, int c, int border_type, cv::Scalar borderVal = cv::Scalar())
 {
     if (border_type == cv::BORDER_CONSTANT)
@@ -113,7 +116,7 @@ template <typename T> struct CubicInterpolator
             for (float cx = xmin; cx <= xmax; cx += 1.0f)
             {
                 const float w = bicubicCoeff(x - cx) * bicubicCoeff(y - cy);
-                sum += w * readVal<T>(src, cvFloor(cy), cvFloor(cx), c, border_type, borderVal);
+                sum += w * readVal<T>(src, (int) floorf(cy), (int) floorf(cx), c, border_type, borderVal);
                 wsum += w;
             }
         }

From ee291a15da3614cf8e76a18378de0eb9c4e69a4b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 00:16:23 +0400
Subject: [PATCH 131/155] add preprocessing only function

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   3 +
 modules/gpu/src/cuda/icf-sc.cu          | 103 ++++++++++++++++++++++++
 modules/gpu/src/softcascade.cpp         |  33 ++++++++
 3 files changed, 139 insertions(+)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 2bbfe532f..bdb9f8c6c 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1576,6 +1576,9 @@ public:
     // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
 
+    // Preprocesing only
+    virtual void preprocess(InputArray image, OutputArray channels, Stream& stream = Stream::Null()) const;
+
     // Convert ROI matrix into the suitable for detect method.
     // Param roi is an input matrix of the same size as the image.
     //    There non zero value mean that detector should be executed in this point.
diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 9f1661c63..f59b08e59 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -41,6 +41,7 @@
 //M*/
 
 #include <opencv2/gpu/device/common.hpp>
+#include <opencv2/gpu/device/saturate_cast.hpp>
 
 #include <icf.hpp>
 #include <float.h>
@@ -49,6 +50,108 @@
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
+    __device__ __forceinline__ void luv(const float& b, const float& g, const float& r, uchar& __l, uchar& __u, uchar& __v)
+    {
+        // rgb -> XYZ
+        float x = 0.412453f * r + 0.357580f * g + 0.180423f * b;
+        float y = 0.212671f * r + 0.715160f * g + 0.072169f * b;
+        float z = 0.019334f * r + 0.119193f * g + 0.950227f * b;
+
+        // computed for D65
+        const float _ur = 0.19783303699678276f;
+        const float _vr = 0.46833047435252234f;
+
+        const float divisor = fmax((x + 15.f * y + 3.f * z), FLT_EPSILON);
+        const float _u = __fdividef(4.f * x, divisor);
+        const float _v = __fdividef(9.f * y, divisor);
+
+        const float L = fmax(0.f, ((116.f * cbrtf(y)) - 16.f));
+        const float U = 13.f * L * (_u - _ur);
+        const float V = 13.f * L * (_v - _vr);
+
+        // L in [0, 100], u in [-134, 220], v in [-140, 122]
+        __l = static_cast<uchar>( L * (255.f / 100.f));
+        __u = static_cast<uchar>((U + 134.f) * (255.f / (220.f + 134.f )));
+        __v = static_cast<uchar>((V + 140.f) * (255.f / (122.f + 140.f )));
+    }
+
+    __global__ void bgr2Luv_d(const uchar* rgb, const int rgbPitch, uchar* luvg, const int luvgPitch)
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+        uchar3 color = ((uchar3*)(rgb + rgbPitch * y))[x];
+        uchar l, u, v;
+        luv(color.x / 255.f, color.y / 255.f, color.z / 255.f, l, u, v);
+
+        luvg[luvgPitch *  y + x] = l;
+        luvg[luvgPitch * (y + 480) + x] = u;
+        luvg[luvgPitch * (y + 2 * 480) + x] = v;
+    }
+
+    void bgr2Luv(const PtrStepSzb& bgr, PtrStepSzb luv)
+    {
+        dim3 block(32, 8);
+        dim3 grid(bgr.cols / 32, bgr.rows / 8);
+
+        bgr2Luv_d<<<grid, block>>>((const uchar*)bgr.ptr(0), bgr.step, (uchar*)luv.ptr(0), luv.step);
+
+        cudaSafeCall(cudaDeviceSynchronize());
+    }
+
+    __device__ __forceinline__ int fast_angle_bin(const float& dx, const float& dy)
+    {
+        const float angle_quantum = M_PI / 6.f;
+        float angle = atan2(dx, dy) + (angle_quantum / 2.f);
+
+        if (angle < 0) angle += M_PI;
+
+        const float angle_scaling = 1.f / angle_quantum;
+        return static_cast<int>(angle * angle_scaling) % 6;
+    }
+
+    texture<uchar,  cudaTextureType2D, cudaReadModeElementType> tgray;
+
+    __global__ void magnitude_d(PtrStepSzb mag)
+    {
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+
+        const float dx_a = tex2D(tgray, x + 1, y),
+                    dx_b = tex2D(tgray, x - 1, y),
+                    dx = dx_a - dx_b,
+
+                    dy_a = tex2D(tgray, x, y + 1),
+                    dy_b = tex2D(tgray, x, y - 1),
+                    dy = dy_a - dy_b;
+
+
+        const float magnitude_scaling = 1.0f/ sqrtf(2);
+
+        const float magnitude = sqrtf((dx * dx) + (dy * dy)) * magnitude_scaling;
+        const uchar magnitude_u8 = static_cast<uchar>(magnitude);
+
+        mag( 480 * 6 + y, x) = magnitude_u8;
+
+        int angle_channel_index;
+
+        angle_channel_index = fast_angle_bin(dy, dx);
+        mag( 480 * angle_channel_index + y, x) = magnitude_u8;
+    }
+
+    void magnitude(const PtrStepSzb& gray, PtrStepSzb mag)
+    {
+        dim3 block(32, 8);
+        dim3 grid(gray.cols / 32, gray.rows / 8);
+
+        cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar>();
+        cudaSafeCall( cudaBindTexture2D(0, tgray, gray.data, desc, gray.cols, gray.rows, gray.step) );
+
+        magnitude_d<<<grid, block>>>(mag);
+
+        cudaSafeCall(cudaDeviceSynchronize());
+    }
+
     // ToDo: use textures or uncached load instruction.
     __global__ void magToHist(const uchar* __restrict__ mag,
                               const float* __restrict__ angle, const int angPitch,
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 431eeba0e..1d3273618 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -88,6 +88,9 @@ namespace icf {
 
     void suppress(const PtrStepSzb& objects, PtrStepSzb overlaps, PtrStepSzi ndetections,
         PtrStepSzb suppressed, cudaStream_t stream);
+
+    void bgr2Luv(const PtrStepSzb& bgr, PtrStepSzb luv);
+    void magnitude(const PtrStepSzb& gray, PtrStepSzb mag);
 }
 
 namespace imgproc {
@@ -606,4 +609,34 @@ void cv::gpu::SCascade::read(const FileNode& fn)
     Algorithm::read(fn);
 }
 
+namespace {
+
+void bgr2Luv(const cv::gpu::GpuMat& input, cv::gpu::GpuMat& integral)
+{
+    cv::gpu::GpuMat bgr;
+    cv::gpu::GaussianBlur(input, bgr, cv::Size(3, 3), -1);
+
+    cv::gpu::GpuMat gray, luv, shrunk, buffer;
+    luv.create(bgr.rows * 10, bgr.cols, CV_8UC1);
+    luv.setTo(0);
+
+    cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
+    cv::gpu::device::icf::magnitude(gray, luv(cv::Rect(0, 0, bgr.cols, bgr.rows * 7)));
+
+    cv::gpu::GpuMat __luv(luv, cv::Rect(0, bgr.rows * 7, bgr.cols, bgr.rows * 3));
+    cv::gpu::device::icf::bgr2Luv(bgr, __luv);
+
+    cv::gpu::resize(luv, shrunk, cv::Size(), 0.25f, 0.25f, CV_INTER_AREA);
+    cv::gpu::integralBuffered(shrunk, integral, buffer);
+}
+}
+
+void cv::gpu::SCascade::preprocess(InputArray _bgr, OutputArray _channels, Stream& stream) const
+{
+    CV_Assert(fields);
+    (void)stream;
+    const GpuMat bgr = _bgr.getGpuMat(), channels = _channels.getGpuMat();
+}
+
+
 #endif
\ No newline at end of file

From 0e1005ca92c2e5a979f4b9e92f8649ec8d02fd10 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 15:40:00 +0400
Subject: [PATCH 132/155] optimize hog bin computing

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  25 +++++-
 modules/gpu/src/cuda/icf-sc.cu          |  92 +++++++++++++++-----
 modules/gpu/src/softcascade.cpp         | 108 +++++++++++++++++++-----
 3 files changed, 181 insertions(+), 44 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index bdb9f8c6c..7003c8f56 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1534,6 +1534,28 @@ class CV_EXPORTS SCascade : public Algorithm
 {
 public:
 
+    enum { GENERIC = 1, SEPARABLE = 2};
+    class CV_EXPORTS Preprocessor
+    {
+    public:
+
+        // Appends specified number of HOG first-order features integrals into given vector.
+        // Param frame is an input 3-channel bgr image.
+        // Param channels is a GPU matrix of integrals.
+        // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution.
+        virtual void apply(InputArray frame, OutputArray channels, Stream& stream = Stream::Null()) = 0;
+
+        // Creates a specific preprocessor implementation.
+        // Param shrinkage is a resizing factor. Resize is applied before the computing integral sum
+        // Param bins is a number of HOG-like channels.
+        // Param method is a channel computing method.
+        static cv::Ptr<Preprocessor> create(const int shrinkage, const int bins, const int method = GENERIC);
+
+
+    protected:
+        Preprocessor();
+    };
+
     // Representation of detectors result.
     struct CV_EXPORTS Detection
     {
@@ -1576,9 +1598,6 @@ public:
     // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
 
-    // Preprocesing only
-    virtual void preprocess(InputArray image, OutputArray channels, Stream& stream = Stream::Null()) const;
-
     // Convert ROI matrix into the suitable for detect method.
     // Param roi is an input matrix of the same size as the image.
     //    There non zero value mean that detector should be executed in this point.
diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index f59b08e59..812be7a0e 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -99,6 +99,7 @@ namespace icf {
         cudaSafeCall(cudaDeviceSynchronize());
     }
 
+    template<bool isDefaultNum>
     __device__ __forceinline__ int fast_angle_bin(const float& dx, const float& dy)
     {
         const float angle_quantum = M_PI / 6.f;
@@ -110,36 +111,82 @@ namespace icf {
         return static_cast<int>(angle * angle_scaling) % 6;
     }
 
+    template<>
+    __device__ __forceinline__ int fast_angle_bin<true>(const float& dy, const float& dx)
+    {
+        int index = 0;
+
+        float max_dot = fabs(dx);
+
+        {
+            const float dot_product = fabs(dx * 0.8660254037844386f + dy * 0.5f);
+
+            if(dot_product > max_dot)
+            {
+                max_dot = dot_product;
+                index = 1;
+            }
+        }
+        {
+            const float dot_product = fabs(dy * 0.8660254037844386f + dx * 0.5f);
+
+            if(dot_product > max_dot)
+            {
+                max_dot = dot_product;
+                index = 2;
+            }
+        }
+        {
+            int i = 3;
+            float2 bin_vector_i;
+            bin_vector_i.x = ::cos(i * (M_PI / 6.f));
+            bin_vector_i.y = ::sin(i * (M_PI / 6.f));
+
+            const float dot_product = fabs(dx * bin_vector_i.x + dy * bin_vector_i.y);
+            if(dot_product > max_dot)
+            {
+                max_dot = dot_product;
+                index = i;
+            }
+        }
+        {
+            const float dot_product = fabs(dx * (-0.4999999999999998f) + dy * 0.8660254037844387f);
+            if(dot_product > max_dot)
+            {
+                max_dot = dot_product;
+                index = 4;
+            }
+        }
+        {
+            const float dot_product = fabs(dx * (-0.8660254037844387f) + dy * 0.49999999999999994f);
+            if(dot_product > max_dot)
+            {
+                max_dot = dot_product;
+                index = 5;
+            }
+        }
+        return index;
+    }
+
     texture<uchar,  cudaTextureType2D, cudaReadModeElementType> tgray;
 
-    __global__ void magnitude_d(PtrStepSzb mag)
+    template<bool isDefaultNum>
+    __global__ void gray2hog(PtrStepSzb mag)
     {
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
 
-        const float dx_a = tex2D(tgray, x + 1, y),
-                    dx_b = tex2D(tgray, x - 1, y),
-                    dx = dx_a - dx_b,
+        const float dx = tex2D(tgray, x + 1, y + 0) - tex2D(tgray, x - 1, y - 0);
+        const float dy = tex2D(tgray, x + 0, y + 1) - tex2D(tgray, x - 0, y - 1);
 
-                    dy_a = tex2D(tgray, x, y + 1),
-                    dy_b = tex2D(tgray, x, y - 1),
-                    dy = dy_a - dy_b;
+        const float magnitude = sqrtf((dx * dx) + (dy * dy)) * (1.0f / sqrtf(2));
+        const uchar cmag = static_cast<uchar>(magnitude);
 
-
-        const float magnitude_scaling = 1.0f/ sqrtf(2);
-
-        const float magnitude = sqrtf((dx * dx) + (dy * dy)) * magnitude_scaling;
-        const uchar magnitude_u8 = static_cast<uchar>(magnitude);
-
-        mag( 480 * 6 + y, x) = magnitude_u8;
-
-        int angle_channel_index;
-
-        angle_channel_index = fast_angle_bin(dy, dx);
-        mag( 480 * angle_channel_index + y, x) = magnitude_u8;
+        mag( 480 * 6 + y, x) = cmag;
+        mag( 480 * fast_angle_bin<isDefaultNum>(dy, dx) + y, x) = cmag;
     }
 
-    void magnitude(const PtrStepSzb& gray, PtrStepSzb mag)
+    void gray2hog(const PtrStepSzb& gray, PtrStepSzb mag, const int bins)
     {
         dim3 block(32, 8);
         dim3 grid(gray.cols / 32, gray.rows / 8);
@@ -147,7 +194,10 @@ namespace icf {
         cudaChannelFormatDesc desc = cudaCreateChannelDesc<uchar>();
         cudaSafeCall( cudaBindTexture2D(0, tgray, gray.data, desc, gray.cols, gray.rows, gray.step) );
 
-        magnitude_d<<<grid, block>>>(mag);
+        if (bins == 6)
+            gray2hog<true><<<grid, block>>>(mag);
+        else
+            gray2hog<false><<<grid, block>>>(mag);
 
         cudaSafeCall(cudaDeviceSynchronize());
     }
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 1d3273618..2c7d42b9e 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -57,6 +57,11 @@ void cv::gpu::SCascade::genRoi(InputArray, OutputArray, Stream&) const { throw_n
 
 void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 
+cv::gpu::SCascade::Preprocessor::Preprocessor() { throw_nogpu(); }
+
+void cv::gpu::SCascade::Preprocessor::create(const int, const int, const int) { throw_nogpu(); }
+
+
 #else
 
 #include <icf.hpp>
@@ -90,7 +95,7 @@ namespace icf {
         PtrStepSzb suppressed, cudaStream_t stream);
 
     void bgr2Luv(const PtrStepSzb& bgr, PtrStepSzb luv);
-    void magnitude(const PtrStepSzb& gray, PtrStepSzb mag);
+    void gray2hog(const PtrStepSzb& gray, PtrStepSzb mag, const int bins);
 }
 
 namespace imgproc {
@@ -609,34 +614,97 @@ void cv::gpu::SCascade::read(const FileNode& fn)
     Algorithm::read(fn);
 }
 
+// namespace {
+
+// void bgr2Luv(const cv::gpu::GpuMat& input, cv::gpu::GpuMat& luv /*integral*/)
+// {
+//     cv::gpu::GpuMat bgr;
+//     cv::gpu::GaussianBlur(input, bgr, cv::Size(3, 3), -1);
+
+//     cv::gpu::GpuMat gray, /*luv,*/ shrunk, buffer;
+//     luv.create(bgr.rows * 10, bgr.cols, CV_8UC1);
+//     luv.setTo(0);
+
+//     cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
+//     cv::gpu::device::icf::magnitude(gray, luv(cv::Rect(0, 0, bgr.cols, bgr.rows * 7)));
+
+//     cv::gpu::GpuMat __luv(luv, cv::Rect(0, bgr.rows * 7, bgr.cols, bgr.rows * 3));
+//     cv::gpu::device::icf::bgr2Luv(bgr, __luv);
+
+//     // cv::gpu::resize(luv, shrunk, cv::Size(), 0.25f, 0.25f, CV_INTER_AREA);
+//     // cv::gpu::integralBuffered(shrunk, integral, buffer);
+// }
+// }
+
 namespace {
 
-void bgr2Luv(const cv::gpu::GpuMat& input, cv::gpu::GpuMat& integral)
+using cv::InputArray;
+using cv::OutputArray;
+using cv::gpu::Stream;
+using cv::gpu::GpuMat;
+
+struct GenricPreprocessor : public cv::gpu::SCascade::Preprocessor
 {
-    cv::gpu::GpuMat bgr;
-    cv::gpu::GaussianBlur(input, bgr, cv::Size(3, 3), -1);
+    GenricPreprocessor(const int s, const int b) : cv::gpu::SCascade::Preprocessor(), shrinkage(s), bins(b) {}
 
-    cv::gpu::GpuMat gray, luv, shrunk, buffer;
-    luv.create(bgr.rows * 10, bgr.cols, CV_8UC1);
-    luv.setTo(0);
+    virtual void apply(InputArray /*frame*/, OutputArray /*channels*/, Stream& /*s*/ = Stream::Null())
+    {
 
-    cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
-    cv::gpu::device::icf::magnitude(gray, luv(cv::Rect(0, 0, bgr.cols, bgr.rows * 7)));
+    }
 
-    cv::gpu::GpuMat __luv(luv, cv::Rect(0, bgr.rows * 7, bgr.cols, bgr.rows * 3));
-    cv::gpu::device::icf::bgr2Luv(bgr, __luv);
+private:
+    const int shrinkage;
+    const int bins;
+};
 
-    cv::gpu::resize(luv, shrunk, cv::Size(), 0.25f, 0.25f, CV_INTER_AREA);
-    cv::gpu::integralBuffered(shrunk, integral, buffer);
-}
-}
-
-void cv::gpu::SCascade::preprocess(InputArray _bgr, OutputArray _channels, Stream& stream) const
+inline void setZero(cv::gpu::GpuMat& m, Stream& s)
 {
-    CV_Assert(fields);
-    (void)stream;
-    const GpuMat bgr = _bgr.getGpuMat(), channels = _channels.getGpuMat();
+    if (s)
+        s.enqueueMemSet(m, 0);
+    else
+        m.setTo(0);
 }
 
+struct SeparablePreprocessor : public cv::gpu::SCascade::Preprocessor
+{
+    SeparablePreprocessor(const int s, const int b) : cv::gpu::SCascade::Preprocessor(), shrinkage(s), bins(b) {}
+
+    virtual void apply(InputArray _frame, OutputArray _channels, Stream& s = Stream::Null())
+    {
+        const GpuMat frame = _frame.getGpuMat();
+        cv::gpu::GaussianBlur(frame, bgr, cv::Size(3, 3), -1.0);
+
+        _channels.create(frame.rows * (4 + bins), frame.cols, CV_8UC1);
+        GpuMat channels = _channels.getGpuMat();
+        setZero(channels, s);
+
+        cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
+        cv::gpu::device::icf::gray2hog(gray, channels(cv::Rect(0, 0, bgr.cols, bgr.rows * (bins + 1))), bins);
+
+        cv::gpu::GpuMat luv(channels, cv::Rect(0, bgr.rows * (bins + 1), bgr.cols, bgr.rows * 3));
+        cv::gpu::device::icf::bgr2Luv(bgr, luv);
+    }
+
+private:
+    const int shrinkage;
+    const int bins;
+
+    GpuMat bgr;
+    GpuMat gray;
+};
+
+}
+
+cv::gpu::SCascade::Preprocessor::Preprocessor(){}
+
+cv::Ptr<cv::gpu::SCascade::Preprocessor> cv::gpu::SCascade::Preprocessor::create(const int s, const int b, const int m)
+{
+    CV_Assert(m == SEPARABLE || m == GENERIC);
+
+    if (m == GENERIC)
+        return cv::Ptr<cv::gpu::SCascade::Preprocessor>(new GenricPreprocessor(s, b));
+
+    return cv::Ptr<cv::gpu::SCascade::Preprocessor>(new SeparablePreprocessor(s, b));
+}
 
 #endif
\ No newline at end of file

From 8ef19e766417c4add043de681728506e0a881335 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 19:47:51 +0400
Subject: [PATCH 133/155] hack luv

---
 modules/gpu/src/cuda/icf-sc.cu | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 812be7a0e..1b9c02eb2 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -65,7 +65,8 @@ namespace icf {
         const float _u = __fdividef(4.f * x, divisor);
         const float _v = __fdividef(9.f * y, divisor);
 
-        const float L = fmax(0.f, ((116.f * cbrtf(y)) - 16.f));
+        float hack = static_cast<float>(__float2int_rn(y * 2047)) / 2047;
+        const float L = fmax(0.f, ((116.f * cbrtf(hack)) - 16.f));
         const float U = 13.f * L * (_u - _ur);
         const float V = 13.f * L * (_v - _vr);
 

From d23a4f50bd317b105dd80b1c6bd2fd599c80ab9e Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 28 Nov 2012 21:32:35 +0400
Subject: [PATCH 134/155] add resize

---
 modules/gpu/src/cuda/icf-sc.cu  | 35 +++++++++++++++++++++++++++++++++
 modules/gpu/src/softcascade.cpp | 12 ++++++++---
 2 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 1b9c02eb2..58d6883e8 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -50,6 +50,41 @@
 namespace cv { namespace gpu { namespace device {
 namespace icf {
 
+    template <int FACTOR>
+    __device__ __forceinline__ uchar shrink(const uchar* ptr, const int pitch, const int y, const int x)
+    {
+        int out = 0;
+#pragma unroll
+        for(int dy = 0; dy < FACTOR; ++dy)
+#pragma unroll
+            for(int dx = 0; dx < FACTOR; ++dx)
+            {
+                out += ptr[dy * pitch + dx];
+            }
+
+        return static_cast<uchar>(out / (FACTOR * FACTOR));
+    }
+
+    template<int FACTOR>
+    __global__ void shrink(const uchar* __restrict__ hogluv, const int inPitch,
+                                 uchar* __restrict__ shrank, const int outPitch )
+    {
+        const int y = blockIdx.y * blockDim.y + threadIdx.y;
+        const int x = blockIdx.x * blockDim.x + threadIdx.x;
+
+        const uchar* ptr = hogluv + (FACTOR * y) * inPitch + (FACTOR * x);
+
+        shrank[ y * outPitch + x] = shrink<FACTOR>(ptr, inPitch, y, x);
+    }
+
+    void shrink(const cv::gpu::PtrStepSzb& channels, cv::gpu::PtrStepSzb shrunk)
+    {
+        dim3 block(32, 8);
+        dim3 grid(shrunk.cols / 32, shrunk.rows / 8);
+        shrink<4><<<grid, block>>>((uchar*)channels.ptr(), channels.step, (uchar*)shrunk.ptr(), shrunk.step);
+        cudaSafeCall(cudaDeviceSynchronize());
+    }
+
     __device__ __forceinline__ void luv(const float& b, const float& g, const float& r, uchar& __l, uchar& __u, uchar& __v)
     {
         // rgb -> XYZ
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 2c7d42b9e..6d29a1d94 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -96,6 +96,8 @@ namespace icf {
 
     void bgr2Luv(const PtrStepSzb& bgr, PtrStepSzb luv);
     void gray2hog(const PtrStepSzb& gray, PtrStepSzb mag, const int bins);
+
+    void shrink(const cv::gpu::PtrStepSzb& channels, cv::gpu::PtrStepSzb shrunk);
 }
 
 namespace imgproc {
@@ -669,13 +671,15 @@ struct SeparablePreprocessor : public cv::gpu::SCascade::Preprocessor
 {
     SeparablePreprocessor(const int s, const int b) : cv::gpu::SCascade::Preprocessor(), shrinkage(s), bins(b) {}
 
-    virtual void apply(InputArray _frame, OutputArray _channels, Stream& s = Stream::Null())
+    virtual void apply(InputArray _frame, OutputArray _shrunk, Stream& s = Stream::Null())
     {
         const GpuMat frame = _frame.getGpuMat();
         cv::gpu::GaussianBlur(frame, bgr, cv::Size(3, 3), -1.0);
 
-        _channels.create(frame.rows * (4 + bins), frame.cols, CV_8UC1);
-        GpuMat channels = _channels.getGpuMat();
+        _shrunk.create(frame.rows * (4 + bins) / shrinkage, frame.cols / shrinkage, CV_8UC1);
+        GpuMat shrunk = _shrunk.getGpuMat();
+
+        channels.create(frame.rows * (4 + bins), frame.cols, CV_8UC1);
         setZero(channels, s);
 
         cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
@@ -683,6 +687,7 @@ struct SeparablePreprocessor : public cv::gpu::SCascade::Preprocessor
 
         cv::gpu::GpuMat luv(channels, cv::Rect(0, bgr.rows * (bins + 1), bgr.cols, bgr.rows * 3));
         cv::gpu::device::icf::bgr2Luv(bgr, luv);
+        cv::gpu::device::icf::shrink(channels, shrunk);
     }
 
 private:
@@ -691,6 +696,7 @@ private:
 
     GpuMat bgr;
     GpuMat gray;
+    GpuMat channels;
 };
 
 }

From c470e15d4598cbb5927e836082f739e8903fedb4 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 12 Dec 2012 03:43:20 +0400
Subject: [PATCH 135/155] integrate speprocessing strategy

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |  67 +++--
 modules/gpu/perf/perf_softcascade.cpp   |  36 +--
 modules/gpu/src/gpu_init.cpp            |   7 +-
 modules/gpu/src/softcascade.cpp         | 353 +++++++++++-------------
 modules/gpu/test/test_softcascade.cpp   |  21 +-
 5 files changed, 212 insertions(+), 272 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 7003c8f56..866c3de7d 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1529,33 +1529,38 @@ public:
 
 // ======================== GPU version for soft cascade ===================== //
 
+class CV_EXPORTS ChannelsProcessor
+{
+public:
+    enum
+    {
+        GENERIC   = 1 << 4,
+        SEPARABLE = 2 << 4
+    };
+
+    // Appends specified number of HOG first-order features integrals into given vector.
+    // Param frame is an input 3-channel bgr image.
+    // Param channels is a GPU matrix of optionally shrinked channels
+    // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution.
+    virtual void apply(InputArray frame, OutputArray channels, Stream& stream = Stream::Null()) = 0;
+
+    // Creates a specific preprocessor implementation.
+    // Param shrinkage is a resizing factor. Resize is applied before the computing integral sum
+    // Param bins is a number of HOG-like channels.
+    // Param flags is a channel computing extra flags.
+    static cv::Ptr<ChannelsProcessor> create(const int shrinkage, const int bins, const int flags = GENERIC);
+
+    virtual ~ChannelsProcessor();
+
+protected:
+    ChannelsProcessor();
+};
+
 // Implementation of soft (stageless) cascaded detector.
 class CV_EXPORTS SCascade : public Algorithm
 {
 public:
 
-    enum { GENERIC = 1, SEPARABLE = 2};
-    class CV_EXPORTS Preprocessor
-    {
-    public:
-
-        // Appends specified number of HOG first-order features integrals into given vector.
-        // Param frame is an input 3-channel bgr image.
-        // Param channels is a GPU matrix of integrals.
-        // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution.
-        virtual void apply(InputArray frame, OutputArray channels, Stream& stream = Stream::Null()) = 0;
-
-        // Creates a specific preprocessor implementation.
-        // Param shrinkage is a resizing factor. Resize is applied before the computing integral sum
-        // Param bins is a number of HOG-like channels.
-        // Param method is a channel computing method.
-        static cv::Ptr<Preprocessor> create(const int shrinkage, const int bins, const int method = GENERIC);
-
-
-    protected:
-        Preprocessor();
-    };
-
     // Representation of detectors result.
     struct CV_EXPORTS Detection
     {
@@ -1569,14 +1574,15 @@ public:
         enum {PEDESTRIAN = 0};
     };
 
-    enum { NO_REJECT = 1, DOLLAR = 2, /*PASCAL = 4,*/ DEFAULT = NO_REJECT};
+    enum { NO_REJECT = 1, DOLLAR = 2, /*PASCAL = 4,*/ DEFAULT = NO_REJECT, NMS_MASK = 0xF};
 
     // An empty cascade will be created.
     // Param minScale is a minimum scale relative to the original size of the image on which cascade will be applyed.
     // Param minScale is a maximum scale relative to the original size of the image on which cascade will be applyed.
     // Param scales is a number of scales from minScale to maxScale.
-    // Param rejfactor is used for NMS.
-    SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55, const int rejCriteria = 1);
+    // Param flags is an extra tuning flags.
+    SCascade(const double minScale = 0.4, const double maxScale = 5., const int scales = 55,
+        const int flags = NO_REJECT || ChannelsProcessor::GENERIC);
 
     virtual ~SCascade();
 
@@ -1598,13 +1604,6 @@ public:
     // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
     virtual void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const;
 
-    // Convert ROI matrix into the suitable for detect method.
-    // Param roi is an input matrix of the same size as the image.
-    //    There non zero value mean that detector should be executed in this point.
-    // Param mask is an output mask
-    // Param stream is stream is a high-level CUDA stream abstraction used for asynchronous execution
-    virtual void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const;
-
 private:
 
     struct Fields;
@@ -1612,9 +1611,9 @@ private:
 
     double minScale;
     double maxScale;
-
     int scales;
-    int rejCriteria;
+
+    int flags;
 };
 
 CV_EXPORTS bool initModule_gpu(void);
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index b4091d09b..9645beeaf 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -71,15 +71,14 @@ RUN_GPU(SCascadeTest, detect)
 
     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1), trois;
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(1);
-    cascade.genRoi(rois, trois);
 
-    cascade.detect(colored, trois, objectBoxes);
+    cascade.detect(colored, rois, objectBoxes);
 
     TEST_CYCLE()
     {
-        cascade.detect(colored, trois, objectBoxes);
+        cascade.detect(colored, rois, objectBoxes);
     }
 
     SANITY_CHECK(sortDetections(objectBoxes));
@@ -142,14 +141,11 @@ RUN_GPU(SCascadeTestRoi, detectInRoi)
         sub.setTo(1);
     }
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois);
-
-    cascade.detect(colored, trois, objectBoxes);
+    cascade.detect(colored, rois, objectBoxes);
 
     TEST_CYCLE()
     {
-        cascade.detect(colored, trois, objectBoxes);
+        cascade.detect(colored, rois, objectBoxes);
     }
 
     SANITY_CHECK(sortDetections(objectBoxes));
@@ -186,14 +182,11 @@ RUN_GPU(SCascadeTestRoi, detectEachRoi)
     cv::gpu::GpuMat sub(rois, r);
     sub.setTo(1);
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois);
-
-    cascade.detect(colored, trois, objectBoxes);
+    cascade.detect(colored, rois, objectBoxes);
 
     TEST_CYCLE()
     {
-        cascade.detect(colored, trois, objectBoxes);
+        cascade.detect(colored, rois, objectBoxes);
     }
 
     SANITY_CHECK(sortDetections(objectBoxes));
@@ -235,15 +228,14 @@ RUN_GPU(SCascadeTest, detectOnIntegral)
 
     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1), trois;
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
     rois.setTo(1);
-    cascade.genRoi(rois, trois);
 
-    cascade.detect(hogluv, trois, objectBoxes);
+    cascade.detect(hogluv, rois, objectBoxes);
 
     TEST_CYCLE()
     {
-        cascade.detect(hogluv, trois, objectBoxes);
+        cascade.detect(hogluv, rois, objectBoxes);
     }
 
     SANITY_CHECK(sortDetections(objectBoxes));
@@ -270,18 +262,16 @@ RUN_GPU(SCascadeTest, detectStream)
 
     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1), trois;
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(1);
 
     cv::gpu::Stream s;
 
-    cascade.genRoi(rois, trois, s);
-
-    cascade.detect(colored, trois, objectBoxes, s);
+    cascade.detect(colored, rois, objectBoxes, s);
 
     TEST_CYCLE()
     {
-        cascade.detect(colored, trois, objectBoxes, s);
+        cascade.detect(colored, rois, objectBoxes, s);
     }
 
 #ifdef HAVE_CUDA
diff --git a/modules/gpu/src/gpu_init.cpp b/modules/gpu/src/gpu_init.cpp
index 773a8b64e..cffacb833 100644
--- a/modules/gpu/src/gpu_init.cpp
+++ b/modules/gpu/src/gpu_init.cpp
@@ -46,10 +46,9 @@ namespace cv { namespace gpu
 {
 
 CV_INIT_ALGORITHM(SCascade, "CascadeDetector.SCascade",
-                  obj.info()->addParam(obj, "minScale",    obj.minScale);
-                  obj.info()->addParam(obj, "maxScale",    obj.maxScale);
-                  obj.info()->addParam(obj, "scales",      obj.scales);
-                  obj.info()->addParam(obj, "rejCriteria", obj.rejCriteria));
+                  obj.info()->addParam(obj, "minScale", obj.minScale);
+                  obj.info()->addParam(obj, "maxScale", obj.maxScale);
+                  obj.info()->addParam(obj, "scales",   obj.scales));
 
 bool initModule_gpu(void)
 {
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 6d29a1d94..9c9132bb1 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -41,10 +41,8 @@
 //M*/
 
 #include <precomp.hpp>
-#include <opencv2/highgui/highgui.hpp>
 
 #if !defined (HAVE_CUDA)
-
 cv::gpu::SCascade::SCascade(const double, const double, const int, const int) { throw_nogpu(); }
 
 cv::gpu::SCascade::~SCascade() { throw_nogpu(); }
@@ -53,18 +51,16 @@ bool cv::gpu::SCascade::load(const FileNode&) { throw_nogpu(); return false;}
 
 void cv::gpu::SCascade::detect(InputArray, InputArray, OutputArray, Stream&) const { throw_nogpu(); }
 
-void cv::gpu::SCascade::genRoi(InputArray, OutputArray, Stream&) const { throw_nogpu(); }
-
 void cv::gpu::SCascade::read(const FileNode& fn) { Algorithm::read(fn); }
 
-cv::gpu::SCascade::Preprocessor::Preprocessor() { throw_nogpu(); }
-
-void cv::gpu::SCascade::Preprocessor::create(const int, const int, const int) { throw_nogpu(); }
+cv::gpu::ChannelsProcessor::ChannelsProcessor() { throw_nogpu(); }
+ cv::gpu::ChannelsProcessor::~ChannelsProcessor() { throw_nogpu(); }
 
+cv::Ptr<cv::gpu::ChannelsProcessor> cv::gpu::ChannelsProcessor::create(const int, const int, const int)
+{ throw_nogpu(); return cv::Ptr<cv::gpu::ChannelsProcessor>(0); }
 
 #else
-
-#include <icf.hpp>
+# include <icf.hpp>
 
 cv::gpu::device::icf::Level::Level(int idx, const Octave& oct, const float scale, const int w, const int h)
 :  octave(idx), step(oct.stages), relScale(scale / oct.scale)
@@ -96,23 +92,22 @@ namespace icf {
 
     void bgr2Luv(const PtrStepSzb& bgr, PtrStepSzb luv);
     void gray2hog(const PtrStepSzb& gray, PtrStepSzb mag, const int bins);
-
     void shrink(const cv::gpu::PtrStepSzb& channels, cv::gpu::PtrStepSzb shrunk);
 }
 
-namespace imgproc {
-    void shfl_integral_gpu_buffered(PtrStepSzb, PtrStepSz<uint4>, PtrStepSz<unsigned int>, int, cudaStream_t);
+// namespace imgproc {
+//     void shfl_integral_gpu_buffered(PtrStepSzb, PtrStepSz<uint4>, PtrStepSz<unsigned int>, int, cudaStream_t);
 
-    template <typename T>
-    void resize_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy,
-                    PtrStepSzb dst, int interpolation, cudaStream_t stream);
-}
+//     template <typename T>
+//     void resize_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float fx, float fy,
+//                     PtrStepSzb dst, int interpolation, cudaStream_t stream);
+// }
 
 }}}
 
 struct cv::gpu::SCascade::Fields
 {
-    static Fields* parseCascade(const FileNode &root, const float mins, const float maxs, const int totals)
+    static Fields* parseCascade(const FileNode &root, const float mins, const float maxs, const int totals, const int method)
     {
         static const char *const SC_STAGE_TYPE          = "stageType";
         static const char *const SC_BOOST               = "BOOST";
@@ -253,9 +248,9 @@ struct cv::gpu::SCascade::Fields
         CV_Assert(!hleaves.empty());
 
         Fields* fields = new Fields(mins, maxs, totals, origWidth, origHeight, shrinkage, 0,
-            hoctaves, hstages, hnodes, hleaves);
+            hoctaves, hstages, hnodes, hleaves, method);
         fields->voctaves = voctaves;
-        fields->createLevels(FRAME_HEIGHT, FRAME_WIDTH);
+        fields->createLevels(DEFAULT_FRAME_HEIGHT, DEFAULT_FRAME_WIDTH);
 
         return fields;
     }
@@ -310,12 +305,6 @@ struct cv::gpu::SCascade::Fields
 
     bool update(int fh, int fw, int shr)
     {
-        if ((fh == luv.rows) && (fw == luv.cols)) return false;
-
-        plane.create(fh * (HOG_LUV_BINS + 1), fw, CV_8UC1);
-        fplane.create(fh * HOG_BINS, fw, CV_32FC1);
-        luv.create(fh, fw, CV_8UC3);
-
         shrunk.create(fh / shr * HOG_LUV_BINS, fw / shr, CV_8UC1);
         integralBuffer.create(shrunk.rows, shrunk.cols, CV_32SC1);
 
@@ -329,17 +318,19 @@ struct cv::gpu::SCascade::Fields
     }
 
     Fields( const float mins, const float maxs, const int tts, const int ow, const int oh, const int shr, const int ds,
-        cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves)
+        cv::Mat hoctaves, cv::Mat hstages, cv::Mat hnodes, cv::Mat hleaves, int method)
     : minScale(mins), maxScale(maxs), totals(tts), origObjWidth(ow), origObjHeight(oh), shrinkage(shr), downscales(ds)
     {
-        update(FRAME_HEIGHT, FRAME_WIDTH, shr);
+        update(DEFAULT_FRAME_HEIGHT, DEFAULT_FRAME_WIDTH, shr);
         octaves.upload(hoctaves);
         stages.upload(hstages);
         nodes.upload(hnodes);
         leaves.upload(hleaves);
+
+        preprocessor = ChannelsProcessor::create(shrinkage, 6, method);
     }
 
-    void detect(const cv::gpu::GpuMat& roi, cv::gpu::GpuMat& objects, Stream& s) const
+    void detect(cv::gpu::GpuMat& objects, Stream& s) const
     {
         if (s)
             s.enqueueMemSet(objects, 0);
@@ -352,26 +343,7 @@ struct cv::gpu::SCascade::Fields
         = device::icf::CascadeInvoker<device::icf::GK107PolicyX4>(levels, stages, nodes, leaves);
 
         cudaStream_t stream = StreamAccessor::getStream(s);
-        invoker(roi, hogluv, objects, downscales, stream);
-    }
-
-    void preprocess(const cv::gpu::GpuMat& colored, Stream& s)
-    {
-        if (s)
-            s.enqueueMemSet(plane, 0);
-        else
-            cudaMemset(plane.data, 0, plane.step * plane.rows);
-
-        const int fw = colored.cols;
-        const int fh = colored.rows;
-
-        GpuMat gray(plane, cv::Rect(0, fh * Fields::HOG_LUV_BINS, fw, fh));
-        cv::gpu::cvtColor(colored, gray, CV_BGR2GRAY, s);
-        createHogBins(gray ,s);
-
-        createLuvBins(colored, s);
-
-        integrate(fh, fw, s);
+        invoker(mask, hogluv, objects, downscales, stream);
     }
 
     void suppress(GpuMat& objects, Stream& s)
@@ -416,72 +388,10 @@ private:
         return res;
     }
 
-    void createHogBins(const cv::gpu::GpuMat& gray, Stream& s)
-    {
-        static const int fw = gray.cols;
-        static const int fh = gray.rows;
-
-        GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
-        GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
-
-        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, sobelBuf, 3, 1, BORDER_DEFAULT, -1, s);
-        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, sobelBuf, 3, 1, BORDER_DEFAULT, -1, s);
-
-        GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
-        GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
-
-        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true, s);
-
-        // normolize magnitude to uchar interval and angles to 6 bins
-        GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
-        GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
-
-        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2.0f))), nmag, 1, -1, s);
-        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang, 1, -1, s);
-
-        //create uchar magnitude
-        GpuMat cmag(plane, cv::Rect(0, fh * Fields::HOG_BINS, fw, fh));
-        if (s)
-            s.enqueueConvert(nmag, cmag, CV_8UC1);
-        else
-            nmag.convertTo(cmag, CV_8UC1);
-
-        cudaStream_t stream = StreamAccessor::getStream(s);
-        device::icf::fillBins(plane, nang, fw, fh, Fields::HOG_BINS, stream);
-    }
-
-    void createLuvBins(const cv::gpu::GpuMat& colored, Stream& s)
-    {
-        static const int fw = colored.cols;
-        static const int fh = colored.rows;
-
-        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv, s);
-
-        std::vector<GpuMat> splited;
-        for(int i = 0; i < Fields::LUV_BINS; ++i)
-        {
-            splited.push_back(GpuMat(plane, cv::Rect(0, fh * (7 + i), fw, fh)));
-        }
-
-        cv::gpu::split(luv, splited, s);
-    }
-
-    void integrate(const int fh, const int fw, Stream& s)
-    {
-        GpuMat channels(plane, cv::Rect(0, 0, fw, fh * Fields::HOG_LUV_BINS));
-        cv::gpu::resize(channels, shrunk, cv::Size(), 1.f / shrinkage, 1.f / shrinkage, CV_INTER_AREA, s);
-
-        if (info.majorVersion() < 3)
-            cv::gpu::integralBuffered(shrunk, hogluv, integralBuffer, s);
-        else
-        {
-            cudaStream_t stream = StreamAccessor::getStream(s);
-            device::imgproc::shfl_integral_gpu_buffered(shrunk, integralBuffer, hogluv, 12, stream);
-        }
-    }
-
 public:
 
+    cv::Ptr<ChannelsProcessor> preprocessor;
+
     // scales range
     float minScale;
     float maxScale;
@@ -494,14 +404,6 @@ public:
     const int shrinkage;
     int downscales;
 
-    // preallocated buffer 640x480x10 for hogluv + 640x480 got gray
-    GpuMat plane;
-
-    // preallocated buffer for floating point operations
-    GpuMat fplane;
-
-    // temporial mat for cvtColor
-    GpuMat luv;
 
     // 160x120x10
     GpuMat shrunk;
@@ -512,11 +414,12 @@ public:
     // 161x121x10
     GpuMat hogluv;
 
-    // used for area overlap computing during
-    GpuMat overlaps;
 
     // used for suppression
     GpuMat suppressed;
+    // used for area overlap computing during
+    GpuMat overlaps;
+
 
     // Cascade from xml
     GpuMat octaves;
@@ -525,36 +428,36 @@ public:
     GpuMat leaves;
     GpuMat levels;
 
-    GpuMat sobelBuf;
 
-    GpuMat collected;
+    // For ROI
+    GpuMat mask;
+    GpuMat genRoiTmp;
+
+//     GpuMat collected;
 
-    cv::gpu::GpuMat genRoiTmp;
 
     std::vector<device::icf::Octave> voctaves;
 
-    DeviceInfo info;
+//     DeviceInfo info;
 
     enum { BOOST = 0 };
     enum
     {
-        FRAME_WIDTH        = 640,
-        FRAME_HEIGHT       = 480,
-        HOG_BINS           = 6,
-        LUV_BINS           = 3,
-        HOG_LUV_BINS       = 10
+        DEFAULT_FRAME_WIDTH        = 640,
+        DEFAULT_FRAME_HEIGHT       = 480,
+        HOG_LUV_BINS               = 10
     };
 };
 
-cv::gpu::SCascade::SCascade(const double mins, const double maxs, const int sc, const int rjf)
-: fields(0),  minScale(mins), maxScale(maxs), scales(sc), rejCriteria(rjf) {}
+cv::gpu::SCascade::SCascade(const double mins, const double maxs, const int sc, const int fl)
+: fields(0),  minScale(mins), maxScale(maxs), scales(sc), flags(fl) {}
 
 cv::gpu::SCascade::~SCascade() { delete fields; }
 
 bool cv::gpu::SCascade::load(const FileNode& fn)
 {
     if (fields) delete fields;
-    fields = Fields::parseCascade(fn, minScale, maxScale, scales);
+    fields = Fields::parseCascade(fn, minScale, maxScale, scales, flags);
     return fields != 0;
 }
 
@@ -572,12 +475,24 @@ void cv::gpu::SCascade::detect(InputArray _image, InputArray _rois, OutputArray
 
     GpuMat rois = _rois.getGpuMat(), objects = _objects.getGpuMat();
 
+    /// roi
     Fields& flds = *fields;
+    int shr = flds.shrinkage;
+
+    flds.mask.create( rois.cols / shr, rois.rows / shr, rois.type());
+
+    cv::gpu::resize(rois, flds.genRoiTmp, cv::Size(), 1.f / shr, 1.f / shr, CV_INTER_AREA, s);
+    cv::gpu::transpose(flds.genRoiTmp, flds.mask, s);
+
     if (type == CV_8UC3)
     {
-        if (!flds.update(image.rows, image.cols, flds.shrinkage) || flds.check(minScale, maxScale, scales))
+        flds.update(image.rows, image.cols, flds.shrinkage);
+
+        if (flds.check(minScale, maxScale, scales))
             flds.createLevels(image.rows, image.cols);
-        flds.preprocess(image, s);
+
+        flds.preprocessor->apply(image, flds.shrunk);
+        cv::gpu::integralBuffered(flds.shrunk, flds.hogluv, flds.integralBuffer, s);
     }
     else
     {
@@ -587,9 +502,9 @@ void cv::gpu::SCascade::detect(InputArray _image, InputArray _rois, OutputArray
             image.copyTo(flds.hogluv);
     }
 
-    flds.detect(rois, objects, s);
+    flds.detect(objects, s);
 
-    if (rejCriteria != NO_REJECT)
+    if ( (flags && NMS_MASK) != NO_REJECT)
     {
         GpuMat spr(objects, cv::Rect(0, 0, flds.suppressed.cols, flds.suppressed.rows));
         flds.suppress(objects, s);
@@ -597,47 +512,11 @@ void cv::gpu::SCascade::detect(InputArray _image, InputArray _rois, OutputArray
     }
 }
 
-void cv::gpu::SCascade::genRoi(InputArray _roi, OutputArray _mask, Stream& stream) const
-{
-    CV_Assert(fields);
-    int shr = (*fields).shrinkage;
-
-    const GpuMat roi = _roi.getGpuMat();
-    _mask.create( roi.cols / shr, roi.rows / shr, roi.type());
-    GpuMat mask = _mask.getGpuMat();
-
-    GpuMat& tmp =  (*fields).genRoiTmp;
-    cv::gpu::resize(roi, tmp, cv::Size(), 1.f / shr, 1.f / shr, CV_INTER_AREA, stream);
-    cv::gpu::transpose(tmp, mask, stream);
-}
-
 void cv::gpu::SCascade::read(const FileNode& fn)
 {
     Algorithm::read(fn);
 }
 
-// namespace {
-
-// void bgr2Luv(const cv::gpu::GpuMat& input, cv::gpu::GpuMat& luv /*integral*/)
-// {
-//     cv::gpu::GpuMat bgr;
-//     cv::gpu::GaussianBlur(input, bgr, cv::Size(3, 3), -1);
-
-//     cv::gpu::GpuMat gray, /*luv,*/ shrunk, buffer;
-//     luv.create(bgr.rows * 10, bgr.cols, CV_8UC1);
-//     luv.setTo(0);
-
-//     cv::gpu::cvtColor(bgr, gray, CV_BGR2GRAY);
-//     cv::gpu::device::icf::magnitude(gray, luv(cv::Rect(0, 0, bgr.cols, bgr.rows * 7)));
-
-//     cv::gpu::GpuMat __luv(luv, cv::Rect(0, bgr.rows * 7, bgr.cols, bgr.rows * 3));
-//     cv::gpu::device::icf::bgr2Luv(bgr, __luv);
-
-//     // cv::gpu::resize(luv, shrunk, cv::Size(), 0.25f, 0.25f, CV_INTER_AREA);
-//     // cv::gpu::integralBuffered(shrunk, integral, buffer);
-// }
-// }
-
 namespace {
 
 using cv::InputArray;
@@ -645,20 +524,6 @@ using cv::OutputArray;
 using cv::gpu::Stream;
 using cv::gpu::GpuMat;
 
-struct GenricPreprocessor : public cv::gpu::SCascade::Preprocessor
-{
-    GenricPreprocessor(const int s, const int b) : cv::gpu::SCascade::Preprocessor(), shrinkage(s), bins(b) {}
-
-    virtual void apply(InputArray /*frame*/, OutputArray /*channels*/, Stream& /*s*/ = Stream::Null())
-    {
-
-    }
-
-private:
-    const int shrinkage;
-    const int bins;
-};
-
 inline void setZero(cv::gpu::GpuMat& m, Stream& s)
 {
     if (s)
@@ -667,9 +532,102 @@ inline void setZero(cv::gpu::GpuMat& m, Stream& s)
         m.setTo(0);
 }
 
-struct SeparablePreprocessor : public cv::gpu::SCascade::Preprocessor
+struct GenricPreprocessor : public cv::gpu::ChannelsProcessor
 {
-    SeparablePreprocessor(const int s, const int b) : cv::gpu::SCascade::Preprocessor(), shrinkage(s), bins(b) {}
+    GenricPreprocessor(const int s, const int b) : cv::gpu::ChannelsProcessor(), shrinkage(s), bins(b) {}
+    virtual ~GenricPreprocessor() {}
+
+    virtual void apply(InputArray _frame, OutputArray _shrunk, Stream& s = Stream::Null())
+    {
+        const GpuMat frame = _frame.getGpuMat();
+
+        _shrunk.create(frame.rows * (4 + bins) / shrinkage, frame.cols / shrinkage, CV_8UC1);
+        GpuMat shrunk = _shrunk.getGpuMat();
+
+        channels.create(frame.rows * (4 + bins), frame.cols, CV_8UC1);
+        setZero(channels, s);
+
+        cv::gpu::cvtColor(frame, gray, CV_BGR2GRAY, s);
+        createHogBins(s);
+
+        createLuvBins(frame, s);
+
+        cv::gpu::resize(channels, shrunk, cv::Size(), 1.f / shrinkage, 1.f / shrinkage, CV_INTER_AREA, s);
+    }
+
+private:
+
+    void createHogBins(Stream& s)
+    {
+        static const int fw = gray.cols;
+        static const int fh = gray.rows;
+
+        fplane.create(fh * HOG_BINS, fw, CV_32FC1);
+
+        GpuMat dfdx(fplane, cv::Rect(0,  0, fw, fh));
+        GpuMat dfdy(fplane, cv::Rect(0, fh, fw, fh));
+
+        cv::gpu::Sobel(gray, dfdx, CV_32F, 1, 0, sobelBuf, 3, 1, cv::BORDER_DEFAULT, -1, s);
+        cv::gpu::Sobel(gray, dfdy, CV_32F, 0, 1, sobelBuf, 3, 1, cv::BORDER_DEFAULT, -1, s);
+
+        GpuMat mag(fplane, cv::Rect(0, 2 * fh, fw, fh));
+        GpuMat ang(fplane, cv::Rect(0, 3 * fh, fw, fh));
+
+        cv::gpu::cartToPolar(dfdx, dfdy, mag, ang, true, s);
+
+        // normolize magnitude to uchar interval and angles to 6 bins
+        GpuMat nmag(fplane, cv::Rect(0, 4 * fh, fw, fh));
+        GpuMat nang(fplane, cv::Rect(0, 5 * fh, fw, fh));
+
+        cv::gpu::multiply(mag, cv::Scalar::all(1.f / (8 *::log(2.0f))), nmag, 1, -1, s);
+        cv::gpu::multiply(ang, cv::Scalar::all(1.f / 60.f),     nang, 1, -1, s);
+
+        //create uchar magnitude
+        GpuMat cmag(channels, cv::Rect(0, fh * HOG_BINS, fw, fh));
+        if (s)
+            s.enqueueConvert(nmag, cmag, CV_8UC1);
+        else
+            nmag.convertTo(cmag, CV_8UC1);
+
+        cudaStream_t stream = cv::gpu::StreamAccessor::getStream(s);
+        cv::gpu::device::icf::fillBins(channels, nang, fw, fh, HOG_BINS, stream);
+    }
+
+    void createLuvBins(const cv::gpu::GpuMat& colored, Stream& s)
+    {
+        static const int fw = colored.cols;
+        static const int fh = colored.rows;
+
+        cv::gpu::cvtColor(colored, luv, CV_BGR2Luv, s);
+
+        std::vector<GpuMat> splited;
+        for(int i = 0; i < LUV_BINS; ++i)
+        {
+            splited.push_back(GpuMat(channels, cv::Rect(0, fh * (7 + i), fw, fh)));
+        }
+
+        cv::gpu::split(luv, splited, s);
+    }
+
+    enum {HOG_BINS = 6, LUV_BINS = 3};
+
+    const int shrinkage;
+    const int bins;
+
+    GpuMat gray;
+    GpuMat luv;
+    GpuMat channels;
+
+    // preallocated buffer for floating point operations
+    GpuMat fplane;
+    GpuMat sobelBuf;
+};
+
+
+struct SeparablePreprocessor : public cv::gpu::ChannelsProcessor
+{
+    SeparablePreprocessor(const int s, const int b) : cv::gpu::ChannelsProcessor(), shrinkage(s), bins(b) {}
+    virtual ~SeparablePreprocessor() {}
 
     virtual void apply(InputArray _frame, OutputArray _shrunk, Stream& s = Stream::Null())
     {
@@ -701,16 +659,17 @@ private:
 
 }
 
-cv::gpu::SCascade::Preprocessor::Preprocessor(){}
-
-cv::Ptr<cv::gpu::SCascade::Preprocessor> cv::gpu::SCascade::Preprocessor::create(const int s, const int b, const int m)
+cv::Ptr<cv::gpu::ChannelsProcessor> cv::gpu::ChannelsProcessor::create(const int s, const int b, const int m)
 {
-    CV_Assert(m == SEPARABLE || m == GENERIC);
+    CV_Assert((m && SEPARABLE) || (m && GENERIC));
 
-    if (m == GENERIC)
-        return cv::Ptr<cv::gpu::SCascade::Preprocessor>(new GenricPreprocessor(s, b));
+    if (m && GENERIC)
+        return cv::Ptr<cv::gpu::ChannelsProcessor>(new GenricPreprocessor(s, b));
 
-    return cv::Ptr<cv::gpu::SCascade::Preprocessor>(new SeparablePreprocessor(s, b));
+    return cv::Ptr<cv::gpu::ChannelsProcessor>(new SeparablePreprocessor(s, b));
 }
 
+cv::gpu::ChannelsProcessor::ChannelsProcessor() { }
+cv::gpu::ChannelsProcessor::~ChannelsProcessor() { }
+
 #endif
\ No newline at end of file
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 266a7d400..28ef15b1b 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -169,7 +169,7 @@ GPU_TEST_P(SCascadeTestRoi, detect,
 
     ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1), trois;
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
     rois.setTo(0);
 
     int nroi = GET_PARAM(3);
@@ -183,8 +183,8 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
     }
     objectBoxes.setTo(0);
-    cascade.genRoi(rois, trois);
-    cascade.detect(colored, trois, objectBoxes);
+
+    cascade.detect(colored, rois, objectBoxes);
 
     cv::Mat dt(objectBoxes);
     typedef cv::gpu::SCascade::Detection Detection;
@@ -239,10 +239,8 @@ GPU_TEST_P(SCascadeTestAll, detect,
     GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
     sub.setTo(cv::Scalar::all(1));
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois);
     objectBoxes.setTo(0);
-    cascade.detect(colored, trois, objectBoxes);
+    cascade.detect(colored, rois, objectBoxes);
 
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
@@ -279,10 +277,8 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
     GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
     rois.setTo(1);
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois);
     objectBoxes.setTo(0);
-    cascade.detect(hogluv, trois, objectBoxes);
+    cascade.detect(hogluv, rois, objectBoxes);
 
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
@@ -315,12 +311,9 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
 
     cv::gpu::Stream s;
 
-    cv::gpu::GpuMat trois;
-    cascade.genRoi(rois, trois, s);
     objectBoxes.setTo(0);
-    cascade.detect(colored, trois, objectBoxes, s);
-
-    cudaDeviceSynchronize();
+    cascade.detect(colored, rois, objectBoxes, s);
+    s.waitForCompletion();
 
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);

From 9785a8ae34f9a4f1de6f0792762ae5ec1d03dac2 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 12 Dec 2012 04:22:01 +0400
Subject: [PATCH 136/155] fix docs for SCascade

---
 modules/gpu/doc/object_detection.rst | 48 ++++++----------------------
 1 file changed, 9 insertions(+), 39 deletions(-)

diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst
index ce18892a1..a1118b780 100644
--- a/modules/gpu/doc/object_detection.rst
+++ b/modules/gpu/doc/object_detection.rst
@@ -224,9 +224,9 @@ The sample has been rejected if it fall rejection threshold. So stageless cascad
 .. [BMTG12] Rodrigo Benenson, Markus Mathias, Radu Timofte and Luc Van Gool. Pedestrian detection at 100 frames per second. IEEE CVPR, 2012.
 
 
-SCascade
-----------------
-.. ocv:class:: SCascade : public Algorithm
+gpu::SCascade
+-----------------------------------------------
+.. ocv:class:: gpu::SCascade : public Algorithm
 
 Implementation of soft (stageless) cascaded detector. ::
 
@@ -252,45 +252,29 @@ Implementation of soft (stageless) cascaded detector. ::
     };
 
 
-SCascade::SCascade
---------------------------
-An empty cascade will be created.
-
-.. ocv:function:: bool SCascade::SCascade(const float minScale = 0.4f, const float maxScale = 5.f, const int scales = 55, const int rejfactor = 1)
-
-    :param minScale: a minimum scale relative to the original size of the image on which cascade will be applyed.
-
-    :param maxScale: a maximum scale relative to the original size of the image on which cascade will be applyed.
-
-    :param scales: a number of scales from minScale to maxScale.
-
-    :param rejfactor: used for non maximum suppression.
-
-
-
-SCascade::~SCascade
+gpu::SCascade::~SCascade
 ---------------------------
 Destructor for SCascade.
 
-.. ocv:function:: SCascade::~SCascade()
+.. ocv:function:: gpu::SCascade::~SCascade()
 
 
 
-SCascade::load
+gpu::SCascade::load
 --------------------------
 Load cascade from FileNode.
 
-.. ocv:function:: bool SCascade::load(const FileNode& fn)
+.. ocv:function:: bool gpu::SCascade::load(const FileNode& fn)
 
     :param fn: File node from which the soft cascade are read.
 
 
 
-SCascade::detect
+gpu::SCascade::detect
 --------------------------
 Apply cascade to an input frame and return the vector of Decection objcts.
 
-.. ocv:function:: void detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const
+.. ocv:function:: void gpu::SCascade::detect(InputArray image, InputArray rois, OutputArray objects, Stream& stream = Stream::Null()) const
 
     :param image: a frame on which detector will be applied.
 
@@ -301,20 +285,6 @@ Apply cascade to an input frame and return the vector of Decection objcts.
     :param stream: a high-level CUDA stream abstraction used for asynchronous execution.
 
 
-SCascade::genRoi
---------------------------
-Convert ROI matrix into the suitable for detect method.
-
-.. ocv:function:: void genRoi(InputArray roi, OutputArray mask, Stream& stream = Stream::Null()) const
-
-    :param rois: an input matrix of the same size as the image. There non zero value mean that detector should be executed in this point.
-
-    :param mask: an output mask
-
-    :param stream: a high-level CUDA stream abstraction used for asynchronous execution.
-
-
-
 gpu::CascadeClassifier_GPU
 --------------------------
 .. ocv:class:: gpu::CascadeClassifier_GPU

From 5ddf4e4ed7df6a3194b1cd30901461d9cd1b7d5b Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Wed, 12 Dec 2012 09:37:21 +0400
Subject: [PATCH 137/155] change expected values for soft cascade test
 according to changes in implementation

---
 modules/gpu/test/test_softcascade.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 28ef15b1b..cc397404a 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -245,7 +245,7 @@ GPU_TEST_P(SCascadeTestAll, detect,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2460);
+    ASSERT_EQ(a ,2448);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
@@ -318,7 +318,7 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2460);
+    ASSERT_EQ(a ,2448);
 }
 
 

From 889674ef43fb8d2a35883ae31895b34a58089007 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 13 Dec 2012 13:48:24 +0400
Subject: [PATCH 138/155] disabled video decoding under linux

---
 modules/gpu/CMakeLists.txt              | 22 +++++++---------------
 modules/gpu/perf/perf_video.cpp         |  6 +++++-
 modules/gpu/src/cuvid_video_source.cpp  |  2 +-
 modules/gpu/src/cuvid_video_source.h    |  2 +-
 modules/gpu/src/ffmpeg_video_source.cpp |  2 +-
 modules/gpu/src/ffmpeg_video_source.h   |  2 +-
 modules/gpu/src/frame_queue.cpp         |  2 +-
 modules/gpu/src/frame_queue.h           |  2 +-
 modules/gpu/src/precomp.hpp             |  5 +----
 modules/gpu/src/thread_wrappers.cpp     |  2 +-
 modules/gpu/src/thread_wrappers.h       |  2 +-
 modules/gpu/src/video_decoder.cpp       |  2 +-
 modules/gpu/src/video_decoder.h         |  2 +-
 modules/gpu/src/video_parser.cpp        |  2 +-
 modules/gpu/src/video_parser.h          |  2 +-
 modules/gpu/src/video_reader.cpp        |  2 +-
 modules/gpu/test/test_video.cpp         |  8 ++++----
 17 files changed, 30 insertions(+), 37 deletions(-)

diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 1227b93a3..887daa917 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -5,7 +5,7 @@ endif()
 set(the_description "GPU-accelerated Computer Vision")
 ocv_add_module(gpu opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree opencv_photo opencv_legacy)
 
-ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda" "${CMAKE_CURRENT_SOURCE_DIR}/../highgui/src")
+ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda" "${OpenCV_SOURCE_DIR}/modules/highgui/src")
 
 file(GLOB lib_hdrs               "include/opencv2/${name}/*.hpp"               "include/opencv2/${name}/*.h")
 file(GLOB lib_device_hdrs        "include/opencv2/${name}/device/*.hpp"        "include/opencv2/${name}/device/*.h")
@@ -21,16 +21,16 @@ source_group("Src\\Cuda"      FILES ${lib_cuda} ${lib_cuda_hdrs})
 source_group("Device"         FILES ${lib_device_hdrs})
 source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
-if (HAVE_CUDA)
+if(HAVE_CUDA)
   file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp" "src/nvidia/*.h*")
-  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")  
+  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")
   set(ncv_files ${ncv_srcs} ${ncv_cuda})
 
   source_group("Src\\NVidia" FILES ${ncv_files})
-  ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
+
+  ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia" "${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia/core" "${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations /wd4211 /wd4201 /wd4100 /wd4505 /wd4408)
-  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")  
-  #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
+  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
   if(MSVC)
     if(NOT ENABLE_NOISY_WARNINGS)
@@ -46,21 +46,13 @@ if (HAVE_CUDA)
 
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 
-  if(NOT APPLE)
-    unset(CUDA_nvcuvid_LIBRARY CACHE)
+  if(WIN32)
     find_cuda_helper_libs(nvcuvid)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvid_LIBRARY})
-  endif()
 
-  if(WIN32)
-    unset(CUDA_nvcuvenc_LIBRARY CACHE)
     find_cuda_helper_libs(nvcuvenc)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvenc_LIBRARY})
   endif()
-
-  if(NOT APPLE AND WITH_FFMPEG)
-    set(cuda_link_libs ${cuda_link_libs} ${HIGHGUI_LIBRARIES})
-  endif()
 else()
   set(lib_cuda "")
   set(cuda_objs "")
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 5a598ebe5..edbe2aacd 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -996,10 +996,12 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
     }
 }
 
+#ifdef WIN32
+
 //////////////////////////////////////////////////////
 // VideoWriter
 
-PERF_TEST_P(Video, DISABLED_Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
+PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
     declare.time(30);
 
@@ -1096,4 +1098,6 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
     }
 }
 
+#endif
+
 } // namespace
diff --git a/modules/gpu/src/cuvid_video_source.cpp b/modules/gpu/src/cuvid_video_source.cpp
index 5c4691353..0700ba4cd 100644
--- a/modules/gpu/src/cuvid_video_source.cpp
+++ b/modules/gpu/src/cuvid_video_source.cpp
@@ -1,7 +1,7 @@
 #include "cuvid_video_source.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 cv::gpu::detail::CuvidVideoSource::CuvidVideoSource(const std::string& fname)
 {
diff --git a/modules/gpu/src/cuvid_video_source.h b/modules/gpu/src/cuvid_video_source.h
index a06353fed..b9c522cae 100644
--- a/modules/gpu/src/cuvid_video_source.h
+++ b/modules/gpu/src/cuvid_video_source.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/ffmpeg_video_source.cpp b/modules/gpu/src/ffmpeg_video_source.cpp
index 7538de601..fe9771554 100644
--- a/modules/gpu/src/ffmpeg_video_source.cpp
+++ b/modules/gpu/src/ffmpeg_video_source.cpp
@@ -42,7 +42,7 @@
 
 #include "ffmpeg_video_source.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 #if defined(HAVE_FFMPEG) && defined(BUILD_SHARED_LIBS)
     #include "cap_ffmpeg_impl.hpp"
diff --git a/modules/gpu/src/ffmpeg_video_source.h b/modules/gpu/src/ffmpeg_video_source.h
index 66bb7c71c..9ec5559c5 100644
--- a/modules/gpu/src/ffmpeg_video_source.h
+++ b/modules/gpu/src/ffmpeg_video_source.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 struct InputMediaStream_FFMPEG;
 
diff --git a/modules/gpu/src/frame_queue.cpp b/modules/gpu/src/frame_queue.cpp
index 4ed6d0f14..5f0659c7b 100644
--- a/modules/gpu/src/frame_queue.cpp
+++ b/modules/gpu/src/frame_queue.cpp
@@ -42,7 +42,7 @@
 
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 cv::gpu::detail::FrameQueue::FrameQueue() :
     endOfDecode_(0),
diff --git a/modules/gpu/src/frame_queue.h b/modules/gpu/src/frame_queue.h
index 5c049a28e..dc3da7336 100644
--- a/modules/gpu/src/frame_queue.h
+++ b/modules/gpu/src/frame_queue.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/precomp.hpp b/modules/gpu/src/precomp.hpp
index c37332ae4..9310e69f1 100644
--- a/modules/gpu/src/precomp.hpp
+++ b/modules/gpu/src/precomp.hpp
@@ -97,11 +97,8 @@
         #include <cublas.h>
     #endif
 
-    #ifndef __APPLE__
-        #include <nvcuvid.h>
-    #endif
-
     #ifdef WIN32
+        #include <nvcuvid.h>
         #include <NVEncoderAPI.h>
     #endif
 
diff --git a/modules/gpu/src/thread_wrappers.cpp b/modules/gpu/src/thread_wrappers.cpp
index fcfa59827..e88b79243 100644
--- a/modules/gpu/src/thread_wrappers.cpp
+++ b/modules/gpu/src/thread_wrappers.cpp
@@ -42,7 +42,7 @@
 
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 #ifdef WIN32
     #define NOMINMAX
diff --git a/modules/gpu/src/thread_wrappers.h b/modules/gpu/src/thread_wrappers.h
index 9198d3e90..6d6e87c5e 100644
--- a/modules/gpu/src/thread_wrappers.h
+++ b/modules/gpu/src/thread_wrappers.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_decoder.cpp b/modules/gpu/src/video_decoder.cpp
index 41e1d2607..bba28af86 100644
--- a/modules/gpu/src/video_decoder.cpp
+++ b/modules/gpu/src/video_decoder.cpp
@@ -43,7 +43,7 @@
 #include "video_decoder.h"
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 void cv::gpu::detail::VideoDecoder::create(const VideoReader_GPU::FormatInfo& videoFormat)
 {
diff --git a/modules/gpu/src/video_decoder.h b/modules/gpu/src/video_decoder.h
index 9c4dfa929..0b638a0c6 100644
--- a/modules/gpu/src/video_decoder.h
+++ b/modules/gpu/src/video_decoder.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_parser.cpp b/modules/gpu/src/video_parser.cpp
index 2ff14bd75..78f1efe82 100644
--- a/modules/gpu/src/video_parser.cpp
+++ b/modules/gpu/src/video_parser.cpp
@@ -43,7 +43,7 @@
 #include "video_parser.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 cv::gpu::detail::VideoParser::VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue) :
     videoDecoder_(videoDecoder), frameQueue_(frameQueue), unparsedPackets_(0), hasError_(false)
diff --git a/modules/gpu/src/video_parser.h b/modules/gpu/src/video_parser.h
index 3935ffcef..c3c2d1c61 100644
--- a/modules/gpu/src/video_parser.h
+++ b/modules/gpu/src/video_parser.h
@@ -48,7 +48,7 @@
 #include "frame_queue.h"
 #include "video_decoder.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(WIN32)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_reader.cpp b/modules/gpu/src/video_reader.cpp
index df3c2ff2f..d9294d861 100644
--- a/modules/gpu/src/video_reader.cpp
+++ b/modules/gpu/src/video_reader.cpp
@@ -42,7 +42,7 @@
 
 #include "precomp.hpp"
 
-#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || defined(__APPLE__)
+#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || !defined(WIN32)
 
 class cv::gpu::VideoReader_GPU::Impl
 {
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 510d8e744..a4b98bb3d 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -868,11 +868,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
     testing::Values(Channels(1), Channels(3), Channels(4)),
     WHOLE_SUBMAT));
 
+#ifdef WIN32
+
 //////////////////////////////////////////////////////
 // VideoWriter
 
-#ifdef WIN32
-
 PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -934,8 +934,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
     ALL_DEVICES,
     testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
 
-#endif // WIN32
-
 //////////////////////////////////////////////////////
 // VideoReader
 
@@ -976,4 +974,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
     ALL_DEVICES,
     testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
 
+#endif // WIN32
+
 #endif // HAVE_CUDA

From da93a1dab9b84a2dc00489c8c97c5697b9b482a1 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 13 Dec 2012 13:49:32 +0400
Subject: [PATCH 139/155] fixed build for CARMA platform

---
 cmake/OpenCVDetectCUDA.cmake                  |  23 +-
 modules/core/CMakeLists.txt                   |   1 -
 modules/core/src/gpumat.cpp                   |  26 +-
 modules/core/src/opengl_interop.cpp           |  51 +--
 modules/gpu/app/nv_perf_test/CMakeLists.txt   |   2 +-
 .../gpu/include/opencv2/gpu/device/common.hpp |   1 -
 modules/gpu/src/cuda/canny.cu                 |  50 +--
 modules/gpu/src/cuda/ccomponetns.cu           |   3 +-
 modules/gpu/src/cuda/column_filter.h          | 335 +++++++++---------
 modules/gpu/src/cuda/element_operations.cu    | 136 +++----
 modules/gpu/src/cuda/gftt.cu                  |   3 +-
 modules/gpu/src/cuda/global_motion.cu         |  13 +-
 modules/gpu/src/cuda/hist.cu                  |  13 +-
 modules/gpu/src/cuda/hog.cu                   |  16 +-
 modules/gpu/src/cuda/hough.cu                 |   2 +
 modules/gpu/src/cuda/matrix_reductions.cu     |  15 +-
 modules/gpu/src/cuda/optflowbm.cu             |   5 +-
 modules/gpu/src/cuda/orb.cu                   |   1 +
 modules/gpu/src/cuda/pyrlk.cu                 |  37 +-
 modules/gpu/src/cuda/row_filter.h             | 335 +++++++++---------
 modules/gpu/src/cuda/split_merge.cu           |   2 +-
 modules/gpu/src/cuda/tvl1flow.cu              |  36 +-
 modules/gpu/src/imgproc.cpp                   |   2 +-
 .../nvidia/TestHaarCascadeApplication.cpp     |  14 +-
 samples/gpu/driver_api_multi.cpp              |   8 +-
 samples/gpu/driver_api_stereo_multi.cpp       |   2 +-
 samples/gpu/softcascade.cpp                   |   5 +-
 27 files changed, 543 insertions(+), 594 deletions(-)

diff --git a/cmake/OpenCVDetectCUDA.cmake b/cmake/OpenCVDetectCUDA.cmake
index c1cd83866..354ffbf99 100644
--- a/cmake/OpenCVDetectCUDA.cmake
+++ b/cmake/OpenCVDetectCUDA.cmake
@@ -3,12 +3,12 @@ if(${CMAKE_VERSION} VERSION_LESS "2.8.3")
   return()
 endif()
 
-if (WIN32 AND NOT MSVC)
+if(WIN32 AND NOT MSVC)
   message(STATUS "CUDA compilation is disabled (due to only Visual Studio compiler suppoted on your platform).")
   return()
 endif()
 
-if (CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   message(STATUS "CUDA compilation is disabled (due to Clang unsuppoted on your platform).")
   return()
 endif()
@@ -72,11 +72,11 @@ if(CUDA_FOUND)
 
   # Tell NVCC to add PTX intermediate code for the specified architectures
   string(REGEX MATCHALL "[0-9]+" ARCH_LIST "${ARCH_PTX_NO_POINTS}")
-    foreach(ARCH IN LISTS ARCH_LIST)
-      set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=compute_${ARCH})
-      set(OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}")
-      set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
-    endforeach()
+  foreach(ARCH IN LISTS ARCH_LIST)
+    set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=compute_${ARCH})
+    set(OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}")
+    set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
+  endforeach()
 
   # These vars will be processed in other scripts
   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} ${NVCC_FLAGS_EXTRA})
@@ -84,7 +84,7 @@ if(CUDA_FOUND)
 
   message(STATUS "CUDA NVCC target flags: ${CUDA_NVCC_FLAGS}")
 
-  OCV_OPTION(CUDA_FAST_MATH  "Enable --use_fast_math for CUDA compiler " OFF)
+  OCV_OPTION(CUDA_FAST_MATH "Enable --use_fast_math for CUDA compiler " OFF)
 
   if(CUDA_FAST_MATH)
     set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --use_fast_math)
@@ -92,7 +92,6 @@ if(CUDA_FOUND)
 
   mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_VERBOSE_BUILD CUDA_SDK_ROOT_DIR)
 
-  unset(CUDA_npp_LIBRARY CACHE)
   find_cuda_helper_libs(npp)
 
   macro(ocv_cuda_compile VAR)
@@ -106,15 +105,15 @@ if(CUDA_FOUND)
       string(REPLACE "-ggdb3" "" ${var} "${${var}}")
     endforeach()
 
-    if (BUILD_SHARED_LIBS)
+    if(BUILD_SHARED_LIBS)
       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -DCVAPI_EXPORTS)
     endif()
 
     if(UNIX OR APPLE)
-      set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
     endif()
     if(APPLE)
-      set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
+      set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
     endif()
 
     # disabled because of multiple warnings during building nvcc auto generated files
diff --git a/modules/core/CMakeLists.txt b/modules/core/CMakeLists.txt
index cfa14cdcd..4c5112e3f 100644
--- a/modules/core/CMakeLists.txt
+++ b/modules/core/CMakeLists.txt
@@ -10,7 +10,6 @@ if(HAVE_CUDA)
   file(GLOB lib_cuda "src/cuda/*.cu")
   ocv_cuda_compile(cuda_objs ${lib_cuda})
 
-
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 else()
   set(lib_cuda "")
diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
index 6b5b076cd..49f6de389 100644
--- a/modules/core/src/gpumat.cpp
+++ b/modules/core/src/gpumat.cpp
@@ -45,8 +45,7 @@
 #include <iostream>
 
 #ifdef HAVE_CUDA
-    #include <cuda.h>
-    #include <cuda_runtime_api.h>
+    #include <cuda_runtime.h>
     #include <npp.h>
 
     #define CUDART_MINIMUM_REQUIRED_VERSION 4010
@@ -394,18 +393,6 @@ void cv::gpu::DeviceInfo::queryMemory(size_t& free_memory, size_t& total_memory)
 
 namespace
 {
-    template <class T> void getCudaAttribute(T *attribute, CUdevice_attribute device_attribute, int device)
-    {
-        *attribute = T();
-        //CUresult error = CUDA_SUCCESS;// = cuDeviceGetAttribute( attribute, device_attribute, device ); why link erros under ubuntu??
-        CUresult error = cuDeviceGetAttribute( attribute, device_attribute, device );
-        if( CUDA_SUCCESS == error )
-            return;
-
-        printf("Driver API error = %04d\n", error);
-        cv::gpu::error("driver API error", __FILE__, __LINE__);
-    }
-
     int convertSMVer2Cores(int major, int minor)
     {
         // Defines for GPU Architecture types (using the SM version to determine the # of cores per SM
@@ -466,17 +453,6 @@ void cv::gpu::printCudaDeviceInfo(int device)
             convertSMVer2Cores(prop.major, prop.minor) * prop.multiProcessorCount);
         printf("  GPU Clock Speed:                               %.2f GHz\n", prop.clockRate * 1e-6f);
 
-        // This is not available in the CUDA Runtime API, so we make the necessary calls the driver API to support this for output
-        int memoryClock, memBusWidth, L2CacheSize;
-        getCudaAttribute<int>( &memoryClock, CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, dev );
-        getCudaAttribute<int>( &memBusWidth, CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, dev );
-        getCudaAttribute<int>( &L2CacheSize, CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, dev );
-
-        printf("  Memory Clock rate:                             %.2f Mhz\n", memoryClock * 1e-3f);
-        printf("  Memory Bus Width:                              %d-bit\n", memBusWidth);
-        if (L2CacheSize)
-            printf("  L2 Cache Size:                                 %d bytes\n", L2CacheSize);
-
         printf("  Max Texture Dimension Size (x,y,z)             1D=(%d), 2D=(%d,%d), 3D=(%d,%d,%d)\n",
             prop.maxTexture1D, prop.maxTexture2D[0], prop.maxTexture2D[1],
             prop.maxTexture3D[0], prop.maxTexture3D[1], prop.maxTexture3D[2]);
diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp
index 86c85589d..befc63f3f 100644
--- a/modules/core/src/opengl_interop.cpp
+++ b/modules/core/src/opengl_interop.cpp
@@ -44,11 +44,13 @@
 #include "opencv2/core/opengl_interop.hpp"
 #include "opencv2/core/gpumat.hpp"
 
-#include "gl_core_3_1.hpp"
+#ifdef HAVE_OPENGL
+    #include "gl_core_3_1.hpp"
 
-#ifdef HAVE_CUDA
-    #include <cuda_runtime.h>
-    #include <cuda_gl_interop.h>
+    #ifdef HAVE_CUDA
+        #include <cuda_runtime.h>
+        #include <cuda_gl_interop.h>
+    #endif
 #endif
 
 using namespace std;
@@ -61,24 +63,24 @@ namespace
         void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); }
     #else
         void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); }
-    #endif
 
-    #ifndef HAVE_CUDA
-        void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); }
-    #else
-        void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); }
+        #ifndef HAVE_CUDA
+            void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); }
+        #else
+            void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); }
 
-        #if defined(__GNUC__)
-            #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
-        #else /* defined(__CUDACC__) || defined(__MSVC__) */
-            #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
+            #if defined(__GNUC__)
+                #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__, __func__)
+            #else /* defined(__CUDACC__) || defined(__MSVC__) */
+                #define cudaSafeCall(expr)  ___cudaSafeCall(expr, __FILE__, __LINE__)
+            #endif
+
+            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);
+            }
         #endif
-
-        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);
-        }
     #endif
 }
 
@@ -139,11 +141,16 @@ namespace
 
 void cv::gpu::setGlDevice(int device)
 {
-#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER)
+#ifndef HAVE_OPENGL
     (void) device;
-    throw_nocuda();
+    throw_nogl();
 #else
-    cudaSafeCall( cudaGLSetGLDevice(device) );
+    #if !defined(HAVE_CUDA) || defined(CUDA_DISABLER)
+        (void) device;
+        throw_nocuda();
+    #else
+        cudaSafeCall( cudaGLSetGLDevice(device) );
+    #endif
 #endif
 }
 
diff --git a/modules/gpu/app/nv_perf_test/CMakeLists.txt b/modules/gpu/app/nv_perf_test/CMakeLists.txt
index 0793b4493..c13f5ef46 100644
--- a/modules/gpu/app/nv_perf_test/CMakeLists.txt
+++ b/modules/gpu/app/nv_perf_test/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8.6)
+cmake_minimum_required(VERSION 2.8.3)
 
 project(nv_perf_test)
 
diff --git a/modules/gpu/include/opencv2/gpu/device/common.hpp b/modules/gpu/include/opencv2/gpu/device/common.hpp
index ffe2c98b8..e44c8442f 100644
--- a/modules/gpu/include/opencv2/gpu/device/common.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/common.hpp
@@ -100,7 +100,6 @@ namespace cv { namespace gpu
         typedef unsigned char uchar;
         typedef unsigned short ushort;
         typedef signed char schar;
-        typedef unsigned int uint;
 
         template<class T> inline void bindTexture(const textureReference* tex, const PtrStepSz<T>& img)
         {
diff --git a/modules/gpu/src/cuda/canny.cu b/modules/gpu/src/cuda/canny.cu
index ae9cac831..0a5daebaa 100644
--- a/modules/gpu/src/cuda/canny.cu
+++ b/modules/gpu/src/cuda/canny.cu
@@ -52,7 +52,7 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace canny
 {
     struct L1 : binary_function<int, int, float>
     {
@@ -78,17 +78,17 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits<L1> : DefaultTransformFunctorTraits<L1>
+    template <> struct TransformFunctorTraits<canny::L1> : DefaultTransformFunctorTraits<canny::L1>
     {
         enum { smart_shift = 4 };
     };
-    template <> struct TransformFunctorTraits<L2> : DefaultTransformFunctorTraits<L2>
+    template <> struct TransformFunctorTraits<canny::L2> : DefaultTransformFunctorTraits<canny::L2>
     {
         enum { smart_shift = 4 };
     };
 }}}
 
-namespace
+namespace canny
 {
     texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_src(false, cudaFilterModePoint, cudaAddressModeClamp);
     struct SrcTex
@@ -104,7 +104,7 @@ namespace
     };
 
     template <class Norm> __global__
-    void calcMagnitude(const SrcTex src, PtrStepi dx, PtrStepi dy, PtrStepSzf mag, const Norm norm)
+    void calcMagnitudeKernel(const SrcTex src, PtrStepi dx, PtrStepi dy, PtrStepSzf mag, const Norm norm)
     {
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -120,10 +120,7 @@ namespace
 
         mag(y, x) = norm(dxVal, dyVal);
     }
-}
 
-namespace canny
-{
     void calcMagnitude(PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, bool L2Grad)
     {
         const dim3 block(16, 16);
@@ -135,12 +132,12 @@ namespace canny
         if (L2Grad)
         {
             L2 norm;
-            ::calcMagnitude<<<grid, block>>>(src, dx, dy, mag, norm);
+            calcMagnitudeKernel<<<grid, block>>>(src, dx, dy, mag, norm);
         }
         else
         {
             L1 norm;
-            ::calcMagnitude<<<grid, block>>>(src, dx, dy, mag, norm);
+            calcMagnitudeKernel<<<grid, block>>>(src, dx, dy, mag, norm);
         }
 
         cudaSafeCall( cudaGetLastError() );
@@ -165,11 +162,11 @@ namespace canny
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace canny
 {
     texture<float, cudaTextureType2D, cudaReadModeElementType> tex_mag(false, cudaFilterModePoint, cudaAddressModeClamp);
 
-    __global__ void calcMap(const PtrStepSzi dx, const PtrStepi dy, PtrStepi map, const float low_thresh, const float high_thresh)
+    __global__ void calcMapKernel(const PtrStepSzi dx, const PtrStepi dy, PtrStepi map, const float low_thresh, const float high_thresh)
     {
         const int CANNY_SHIFT = 15;
         const int TG22 = (int)(0.4142135623730950488016887242097*(1<<CANNY_SHIFT) + 0.5);
@@ -220,10 +217,7 @@ namespace
 
         map(y, x) = edge_type;
     }
-}
 
-namespace canny
-{
     void calcMap(PtrStepSzi dx, PtrStepSzi dy, PtrStepSzf mag, PtrStepSzi map, float low_thresh, float high_thresh)
     {
         const dim3 block(16, 16);
@@ -231,7 +225,7 @@ namespace canny
 
         bindTexture(&tex_mag, mag);
 
-        ::calcMap<<<grid, block>>>(dx, dy, map, low_thresh, high_thresh);
+        calcMapKernel<<<grid, block>>>(dx, dy, map, low_thresh, high_thresh);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -240,11 +234,11 @@ namespace canny
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace canny
 {
     __device__ int counter = 0;
 
-    __global__ void edgesHysteresisLocal(PtrStepSzi map, ushort2* st)
+    __global__ void edgesHysteresisLocalKernel(PtrStepSzi map, ushort2* st)
     {
         __shared__ volatile int smem[18][18];
 
@@ -325,10 +319,7 @@ namespace
             st[ind] = make_ushort2(x, y);
         }
     }
-}
 
-namespace canny
-{
     void edgesHysteresisLocal(PtrStepSzi map, ushort2* st1)
     {
         void* counter_ptr;
@@ -339,7 +330,7 @@ namespace canny
         const dim3 block(16, 16);
         const dim3 grid(divUp(map.cols, block.x), divUp(map.rows, block.y));
 
-        ::edgesHysteresisLocal<<<grid, block>>>(map, st1);
+        edgesHysteresisLocalKernel<<<grid, block>>>(map, st1);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -348,12 +339,12 @@ namespace canny
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace canny
 {
     __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(PtrStepSzi map, ushort2* st1, ushort2* st2, const int count)
+    __global__ void edgesHysteresisGlobalKernel(PtrStepSzi map, ushort2* st1, ushort2* st2, const int count)
     {
         const int stack_size = 512;
 
@@ -439,14 +430,11 @@ namespace
                 st2[ind + i] = s_st[i];
         }
     }
-}
 
-namespace canny
-{
     void edgesHysteresisGlobal(PtrStepSzi map, ushort2* st1, ushort2* st2)
     {
         void* counter_ptr;
-        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, ::counter) );
+        cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, canny::counter) );
 
         int count;
         cudaSafeCall( cudaMemcpy(&count, counter_ptr, sizeof(int), cudaMemcpyDeviceToHost) );
@@ -458,7 +446,7 @@ namespace canny
             const dim3 block(128);
             const dim3 grid(::min(count, 65535u), divUp(count, 65535), 1);
 
-            ::edgesHysteresisGlobal<<<grid, block>>>(map, st1, st2, count);
+            edgesHysteresisGlobalKernel<<<grid, block>>>(map, st1, st2, count);
             cudaSafeCall( cudaGetLastError() );
 
             cudaSafeCall( cudaDeviceSynchronize() );
@@ -472,7 +460,7 @@ namespace canny
 
 //////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace canny
 {
     struct GetEdges : unary_function<int, uchar>
     {
@@ -488,7 +476,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits<GetEdges> : DefaultTransformFunctorTraits<GetEdges>
+    template <> struct TransformFunctorTraits<canny::GetEdges> : DefaultTransformFunctorTraits<canny::GetEdges>
     {
         enum { smart_shift = 4 };
     };
diff --git a/modules/gpu/src/cuda/ccomponetns.cu b/modules/gpu/src/cuda/ccomponetns.cu
index 62e81376a..c094e08c0 100644
--- a/modules/gpu/src/cuda/ccomponetns.cu
+++ b/modules/gpu/src/cuda/ccomponetns.cu
@@ -497,6 +497,7 @@ namespace cv { namespace gpu { namespace device
 
         void labelComponents(const PtrStepSzb& edges, PtrStepSzi comps, int flags, cudaStream_t stream)
         {
+            (void) flags;
             dim3 block(CTA_SIZE_X, CTA_SIZE_Y);
             dim3 grid(divUp(edges.cols, TILE_COLS), divUp(edges.rows, TILE_ROWS));
 
@@ -529,4 +530,4 @@ namespace cv { namespace gpu { namespace device
     }
 } } }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/column_filter.h b/modules/gpu/src/cuda/column_filter.h
index dbcd09fa3..52b910339 100644
--- a/modules/gpu/src/cuda/column_filter.h
+++ b/modules/gpu/src/cuda/column_filter.h
@@ -49,20 +49,12 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace column_filter
 {
     #define MAX_KERNEL_SIZE 32
 
     __constant__ float c_kernel[MAX_KERNEL_SIZE];
 
-    void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
-    {
-        if (stream == 0)
-            cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
-        else
-            cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
-    }
-
     template <int KSIZE, typename T, typename D, typename B>
     __global__ void linearColumnFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
     {
@@ -196,182 +188,185 @@ namespace filter
         {
             {
                 0,
-                ::caller< 1, T, D, BrdColReflect101>,
-                ::caller< 2, T, D, BrdColReflect101>,
-                ::caller< 3, T, D, BrdColReflect101>,
-                ::caller< 4, T, D, BrdColReflect101>,
-                ::caller< 5, T, D, BrdColReflect101>,
-                ::caller< 6, T, D, BrdColReflect101>,
-                ::caller< 7, T, D, BrdColReflect101>,
-                ::caller< 8, T, D, BrdColReflect101>,
-                ::caller< 9, T, D, BrdColReflect101>,
-                ::caller<10, T, D, BrdColReflect101>,
-                ::caller<11, T, D, BrdColReflect101>,
-                ::caller<12, T, D, BrdColReflect101>,
-                ::caller<13, T, D, BrdColReflect101>,
-                ::caller<14, T, D, BrdColReflect101>,
-                ::caller<15, T, D, BrdColReflect101>,
-                ::caller<16, T, D, BrdColReflect101>,
-                ::caller<17, T, D, BrdColReflect101>,
-                ::caller<18, T, D, BrdColReflect101>,
-                ::caller<19, T, D, BrdColReflect101>,
-                ::caller<20, T, D, BrdColReflect101>,
-                ::caller<21, T, D, BrdColReflect101>,
-                ::caller<22, T, D, BrdColReflect101>,
-                ::caller<23, T, D, BrdColReflect101>,
-                ::caller<24, T, D, BrdColReflect101>,
-                ::caller<25, T, D, BrdColReflect101>,
-                ::caller<26, T, D, BrdColReflect101>,
-                ::caller<27, T, D, BrdColReflect101>,
-                ::caller<28, T, D, BrdColReflect101>,
-                ::caller<29, T, D, BrdColReflect101>,
-                ::caller<30, T, D, BrdColReflect101>,
-                ::caller<31, T, D, BrdColReflect101>,
-                ::caller<32, T, D, BrdColReflect101>
+                column_filter::caller< 1, T, D, BrdColReflect101>,
+                column_filter::caller< 2, T, D, BrdColReflect101>,
+                column_filter::caller< 3, T, D, BrdColReflect101>,
+                column_filter::caller< 4, T, D, BrdColReflect101>,
+                column_filter::caller< 5, T, D, BrdColReflect101>,
+                column_filter::caller< 6, T, D, BrdColReflect101>,
+                column_filter::caller< 7, T, D, BrdColReflect101>,
+                column_filter::caller< 8, T, D, BrdColReflect101>,
+                column_filter::caller< 9, T, D, BrdColReflect101>,
+                column_filter::caller<10, T, D, BrdColReflect101>,
+                column_filter::caller<11, T, D, BrdColReflect101>,
+                column_filter::caller<12, T, D, BrdColReflect101>,
+                column_filter::caller<13, T, D, BrdColReflect101>,
+                column_filter::caller<14, T, D, BrdColReflect101>,
+                column_filter::caller<15, T, D, BrdColReflect101>,
+                column_filter::caller<16, T, D, BrdColReflect101>,
+                column_filter::caller<17, T, D, BrdColReflect101>,
+                column_filter::caller<18, T, D, BrdColReflect101>,
+                column_filter::caller<19, T, D, BrdColReflect101>,
+                column_filter::caller<20, T, D, BrdColReflect101>,
+                column_filter::caller<21, T, D, BrdColReflect101>,
+                column_filter::caller<22, T, D, BrdColReflect101>,
+                column_filter::caller<23, T, D, BrdColReflect101>,
+                column_filter::caller<24, T, D, BrdColReflect101>,
+                column_filter::caller<25, T, D, BrdColReflect101>,
+                column_filter::caller<26, T, D, BrdColReflect101>,
+                column_filter::caller<27, T, D, BrdColReflect101>,
+                column_filter::caller<28, T, D, BrdColReflect101>,
+                column_filter::caller<29, T, D, BrdColReflect101>,
+                column_filter::caller<30, T, D, BrdColReflect101>,
+                column_filter::caller<31, T, D, BrdColReflect101>,
+                column_filter::caller<32, T, D, BrdColReflect101>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdColReplicate>,
-                ::caller< 2, T, D, BrdColReplicate>,
-                ::caller< 3, T, D, BrdColReplicate>,
-                ::caller< 4, T, D, BrdColReplicate>,
-                ::caller< 5, T, D, BrdColReplicate>,
-                ::caller< 6, T, D, BrdColReplicate>,
-                ::caller< 7, T, D, BrdColReplicate>,
-                ::caller< 8, T, D, BrdColReplicate>,
-                ::caller< 9, T, D, BrdColReplicate>,
-                ::caller<10, T, D, BrdColReplicate>,
-                ::caller<11, T, D, BrdColReplicate>,
-                ::caller<12, T, D, BrdColReplicate>,
-                ::caller<13, T, D, BrdColReplicate>,
-                ::caller<14, T, D, BrdColReplicate>,
-                ::caller<15, T, D, BrdColReplicate>,
-                ::caller<16, T, D, BrdColReplicate>,
-                ::caller<17, T, D, BrdColReplicate>,
-                ::caller<18, T, D, BrdColReplicate>,
-                ::caller<19, T, D, BrdColReplicate>,
-                ::caller<20, T, D, BrdColReplicate>,
-                ::caller<21, T, D, BrdColReplicate>,
-                ::caller<22, T, D, BrdColReplicate>,
-                ::caller<23, T, D, BrdColReplicate>,
-                ::caller<24, T, D, BrdColReplicate>,
-                ::caller<25, T, D, BrdColReplicate>,
-                ::caller<26, T, D, BrdColReplicate>,
-                ::caller<27, T, D, BrdColReplicate>,
-                ::caller<28, T, D, BrdColReplicate>,
-                ::caller<29, T, D, BrdColReplicate>,
-                ::caller<30, T, D, BrdColReplicate>,
-                ::caller<31, T, D, BrdColReplicate>,
-                ::caller<32, T, D, BrdColReplicate>
+                column_filter::caller< 1, T, D, BrdColReplicate>,
+                column_filter::caller< 2, T, D, BrdColReplicate>,
+                column_filter::caller< 3, T, D, BrdColReplicate>,
+                column_filter::caller< 4, T, D, BrdColReplicate>,
+                column_filter::caller< 5, T, D, BrdColReplicate>,
+                column_filter::caller< 6, T, D, BrdColReplicate>,
+                column_filter::caller< 7, T, D, BrdColReplicate>,
+                column_filter::caller< 8, T, D, BrdColReplicate>,
+                column_filter::caller< 9, T, D, BrdColReplicate>,
+                column_filter::caller<10, T, D, BrdColReplicate>,
+                column_filter::caller<11, T, D, BrdColReplicate>,
+                column_filter::caller<12, T, D, BrdColReplicate>,
+                column_filter::caller<13, T, D, BrdColReplicate>,
+                column_filter::caller<14, T, D, BrdColReplicate>,
+                column_filter::caller<15, T, D, BrdColReplicate>,
+                column_filter::caller<16, T, D, BrdColReplicate>,
+                column_filter::caller<17, T, D, BrdColReplicate>,
+                column_filter::caller<18, T, D, BrdColReplicate>,
+                column_filter::caller<19, T, D, BrdColReplicate>,
+                column_filter::caller<20, T, D, BrdColReplicate>,
+                column_filter::caller<21, T, D, BrdColReplicate>,
+                column_filter::caller<22, T, D, BrdColReplicate>,
+                column_filter::caller<23, T, D, BrdColReplicate>,
+                column_filter::caller<24, T, D, BrdColReplicate>,
+                column_filter::caller<25, T, D, BrdColReplicate>,
+                column_filter::caller<26, T, D, BrdColReplicate>,
+                column_filter::caller<27, T, D, BrdColReplicate>,
+                column_filter::caller<28, T, D, BrdColReplicate>,
+                column_filter::caller<29, T, D, BrdColReplicate>,
+                column_filter::caller<30, T, D, BrdColReplicate>,
+                column_filter::caller<31, T, D, BrdColReplicate>,
+                column_filter::caller<32, T, D, BrdColReplicate>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdColConstant>,
-                ::caller< 2, T, D, BrdColConstant>,
-                ::caller< 3, T, D, BrdColConstant>,
-                ::caller< 4, T, D, BrdColConstant>,
-                ::caller< 5, T, D, BrdColConstant>,
-                ::caller< 6, T, D, BrdColConstant>,
-                ::caller< 7, T, D, BrdColConstant>,
-                ::caller< 8, T, D, BrdColConstant>,
-                ::caller< 9, T, D, BrdColConstant>,
-                ::caller<10, T, D, BrdColConstant>,
-                ::caller<11, T, D, BrdColConstant>,
-                ::caller<12, T, D, BrdColConstant>,
-                ::caller<13, T, D, BrdColConstant>,
-                ::caller<14, T, D, BrdColConstant>,
-                ::caller<15, T, D, BrdColConstant>,
-                ::caller<16, T, D, BrdColConstant>,
-                ::caller<17, T, D, BrdColConstant>,
-                ::caller<18, T, D, BrdColConstant>,
-                ::caller<19, T, D, BrdColConstant>,
-                ::caller<20, T, D, BrdColConstant>,
-                ::caller<21, T, D, BrdColConstant>,
-                ::caller<22, T, D, BrdColConstant>,
-                ::caller<23, T, D, BrdColConstant>,
-                ::caller<24, T, D, BrdColConstant>,
-                ::caller<25, T, D, BrdColConstant>,
-                ::caller<26, T, D, BrdColConstant>,
-                ::caller<27, T, D, BrdColConstant>,
-                ::caller<28, T, D, BrdColConstant>,
-                ::caller<29, T, D, BrdColConstant>,
-                ::caller<30, T, D, BrdColConstant>,
-                ::caller<31, T, D, BrdColConstant>,
-                ::caller<32, T, D, BrdColConstant>
+                column_filter::caller< 1, T, D, BrdColConstant>,
+                column_filter::caller< 2, T, D, BrdColConstant>,
+                column_filter::caller< 3, T, D, BrdColConstant>,
+                column_filter::caller< 4, T, D, BrdColConstant>,
+                column_filter::caller< 5, T, D, BrdColConstant>,
+                column_filter::caller< 6, T, D, BrdColConstant>,
+                column_filter::caller< 7, T, D, BrdColConstant>,
+                column_filter::caller< 8, T, D, BrdColConstant>,
+                column_filter::caller< 9, T, D, BrdColConstant>,
+                column_filter::caller<10, T, D, BrdColConstant>,
+                column_filter::caller<11, T, D, BrdColConstant>,
+                column_filter::caller<12, T, D, BrdColConstant>,
+                column_filter::caller<13, T, D, BrdColConstant>,
+                column_filter::caller<14, T, D, BrdColConstant>,
+                column_filter::caller<15, T, D, BrdColConstant>,
+                column_filter::caller<16, T, D, BrdColConstant>,
+                column_filter::caller<17, T, D, BrdColConstant>,
+                column_filter::caller<18, T, D, BrdColConstant>,
+                column_filter::caller<19, T, D, BrdColConstant>,
+                column_filter::caller<20, T, D, BrdColConstant>,
+                column_filter::caller<21, T, D, BrdColConstant>,
+                column_filter::caller<22, T, D, BrdColConstant>,
+                column_filter::caller<23, T, D, BrdColConstant>,
+                column_filter::caller<24, T, D, BrdColConstant>,
+                column_filter::caller<25, T, D, BrdColConstant>,
+                column_filter::caller<26, T, D, BrdColConstant>,
+                column_filter::caller<27, T, D, BrdColConstant>,
+                column_filter::caller<28, T, D, BrdColConstant>,
+                column_filter::caller<29, T, D, BrdColConstant>,
+                column_filter::caller<30, T, D, BrdColConstant>,
+                column_filter::caller<31, T, D, BrdColConstant>,
+                column_filter::caller<32, T, D, BrdColConstant>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdColReflect>,
-                ::caller< 2, T, D, BrdColReflect>,
-                ::caller< 3, T, D, BrdColReflect>,
-                ::caller< 4, T, D, BrdColReflect>,
-                ::caller< 5, T, D, BrdColReflect>,
-                ::caller< 6, T, D, BrdColReflect>,
-                ::caller< 7, T, D, BrdColReflect>,
-                ::caller< 8, T, D, BrdColReflect>,
-                ::caller< 9, T, D, BrdColReflect>,
-                ::caller<10, T, D, BrdColReflect>,
-                ::caller<11, T, D, BrdColReflect>,
-                ::caller<12, T, D, BrdColReflect>,
-                ::caller<13, T, D, BrdColReflect>,
-                ::caller<14, T, D, BrdColReflect>,
-                ::caller<15, T, D, BrdColReflect>,
-                ::caller<16, T, D, BrdColReflect>,
-                ::caller<17, T, D, BrdColReflect>,
-                ::caller<18, T, D, BrdColReflect>,
-                ::caller<19, T, D, BrdColReflect>,
-                ::caller<20, T, D, BrdColReflect>,
-                ::caller<21, T, D, BrdColReflect>,
-                ::caller<22, T, D, BrdColReflect>,
-                ::caller<23, T, D, BrdColReflect>,
-                ::caller<24, T, D, BrdColReflect>,
-                ::caller<25, T, D, BrdColReflect>,
-                ::caller<26, T, D, BrdColReflect>,
-                ::caller<27, T, D, BrdColReflect>,
-                ::caller<28, T, D, BrdColReflect>,
-                ::caller<29, T, D, BrdColReflect>,
-                ::caller<30, T, D, BrdColReflect>,
-                ::caller<31, T, D, BrdColReflect>,
-                ::caller<32, T, D, BrdColReflect>
+                column_filter::caller< 1, T, D, BrdColReflect>,
+                column_filter::caller< 2, T, D, BrdColReflect>,
+                column_filter::caller< 3, T, D, BrdColReflect>,
+                column_filter::caller< 4, T, D, BrdColReflect>,
+                column_filter::caller< 5, T, D, BrdColReflect>,
+                column_filter::caller< 6, T, D, BrdColReflect>,
+                column_filter::caller< 7, T, D, BrdColReflect>,
+                column_filter::caller< 8, T, D, BrdColReflect>,
+                column_filter::caller< 9, T, D, BrdColReflect>,
+                column_filter::caller<10, T, D, BrdColReflect>,
+                column_filter::caller<11, T, D, BrdColReflect>,
+                column_filter::caller<12, T, D, BrdColReflect>,
+                column_filter::caller<13, T, D, BrdColReflect>,
+                column_filter::caller<14, T, D, BrdColReflect>,
+                column_filter::caller<15, T, D, BrdColReflect>,
+                column_filter::caller<16, T, D, BrdColReflect>,
+                column_filter::caller<17, T, D, BrdColReflect>,
+                column_filter::caller<18, T, D, BrdColReflect>,
+                column_filter::caller<19, T, D, BrdColReflect>,
+                column_filter::caller<20, T, D, BrdColReflect>,
+                column_filter::caller<21, T, D, BrdColReflect>,
+                column_filter::caller<22, T, D, BrdColReflect>,
+                column_filter::caller<23, T, D, BrdColReflect>,
+                column_filter::caller<24, T, D, BrdColReflect>,
+                column_filter::caller<25, T, D, BrdColReflect>,
+                column_filter::caller<26, T, D, BrdColReflect>,
+                column_filter::caller<27, T, D, BrdColReflect>,
+                column_filter::caller<28, T, D, BrdColReflect>,
+                column_filter::caller<29, T, D, BrdColReflect>,
+                column_filter::caller<30, T, D, BrdColReflect>,
+                column_filter::caller<31, T, D, BrdColReflect>,
+                column_filter::caller<32, T, D, BrdColReflect>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdColWrap>,
-                ::caller< 2, T, D, BrdColWrap>,
-                ::caller< 3, T, D, BrdColWrap>,
-                ::caller< 4, T, D, BrdColWrap>,
-                ::caller< 5, T, D, BrdColWrap>,
-                ::caller< 6, T, D, BrdColWrap>,
-                ::caller< 7, T, D, BrdColWrap>,
-                ::caller< 8, T, D, BrdColWrap>,
-                ::caller< 9, T, D, BrdColWrap>,
-                ::caller<10, T, D, BrdColWrap>,
-                ::caller<11, T, D, BrdColWrap>,
-                ::caller<12, T, D, BrdColWrap>,
-                ::caller<13, T, D, BrdColWrap>,
-                ::caller<14, T, D, BrdColWrap>,
-                ::caller<15, T, D, BrdColWrap>,
-                ::caller<16, T, D, BrdColWrap>,
-                ::caller<17, T, D, BrdColWrap>,
-                ::caller<18, T, D, BrdColWrap>,
-                ::caller<19, T, D, BrdColWrap>,
-                ::caller<20, T, D, BrdColWrap>,
-                ::caller<21, T, D, BrdColWrap>,
-                ::caller<22, T, D, BrdColWrap>,
-                ::caller<23, T, D, BrdColWrap>,
-                ::caller<24, T, D, BrdColWrap>,
-                ::caller<25, T, D, BrdColWrap>,
-                ::caller<26, T, D, BrdColWrap>,
-                ::caller<27, T, D, BrdColWrap>,
-                ::caller<28, T, D, BrdColWrap>,
-                ::caller<29, T, D, BrdColWrap>,
-                ::caller<30, T, D, BrdColWrap>,
-                ::caller<31, T, D, BrdColWrap>,
-                ::caller<32, T, D, BrdColWrap>
+                column_filter::caller< 1, T, D, BrdColWrap>,
+                column_filter::caller< 2, T, D, BrdColWrap>,
+                column_filter::caller< 3, T, D, BrdColWrap>,
+                column_filter::caller< 4, T, D, BrdColWrap>,
+                column_filter::caller< 5, T, D, BrdColWrap>,
+                column_filter::caller< 6, T, D, BrdColWrap>,
+                column_filter::caller< 7, T, D, BrdColWrap>,
+                column_filter::caller< 8, T, D, BrdColWrap>,
+                column_filter::caller< 9, T, D, BrdColWrap>,
+                column_filter::caller<10, T, D, BrdColWrap>,
+                column_filter::caller<11, T, D, BrdColWrap>,
+                column_filter::caller<12, T, D, BrdColWrap>,
+                column_filter::caller<13, T, D, BrdColWrap>,
+                column_filter::caller<14, T, D, BrdColWrap>,
+                column_filter::caller<15, T, D, BrdColWrap>,
+                column_filter::caller<16, T, D, BrdColWrap>,
+                column_filter::caller<17, T, D, BrdColWrap>,
+                column_filter::caller<18, T, D, BrdColWrap>,
+                column_filter::caller<19, T, D, BrdColWrap>,
+                column_filter::caller<20, T, D, BrdColWrap>,
+                column_filter::caller<21, T, D, BrdColWrap>,
+                column_filter::caller<22, T, D, BrdColWrap>,
+                column_filter::caller<23, T, D, BrdColWrap>,
+                column_filter::caller<24, T, D, BrdColWrap>,
+                column_filter::caller<25, T, D, BrdColWrap>,
+                column_filter::caller<26, T, D, BrdColWrap>,
+                column_filter::caller<27, T, D, BrdColWrap>,
+                column_filter::caller<28, T, D, BrdColWrap>,
+                column_filter::caller<29, T, D, BrdColWrap>,
+                column_filter::caller<30, T, D, BrdColWrap>,
+                column_filter::caller<31, T, D, BrdColWrap>,
+                column_filter::caller<32, T, D, BrdColWrap>
             }
         };
 
-        ::loadKernel(kernel, ksize, stream);
+        if (stream == 0)
+            cudaSafeCall( cudaMemcpyToSymbol(column_filter::c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpyToSymbolAsync(column_filter::c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
 
         callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
     }
diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index 071ad89ce..8faaca8bf 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -52,7 +52,7 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace arithm
 {
     template <size_t src_size, size_t dst_size> struct ArithmFuncTraits
     {
@@ -152,7 +152,7 @@ namespace
 //////////////////////////////////////////////////////////////////////////
 // addMat
 
-namespace
+namespace arithm
 {
     template <typename T, typename D> struct VAdd4;
     template <> struct VAdd4<uint, uint> : binary_function<uint, uint, uint>
@@ -336,19 +336,19 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VAdd4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VAdd4<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VAdd2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VAdd2<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< AddMat<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::AddMat<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -446,7 +446,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // addScalar
 
-namespace
+namespace arithm
 {
     template <typename T, typename S, typename D> struct AddScalar : unary_function<T, D>
     {
@@ -463,7 +463,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename S, typename D> struct TransformFunctorTraits< AddScalar<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::AddScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -541,7 +541,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // subMat
 
-namespace
+namespace arithm
 {
     template <typename T, typename D> struct VSub4;
     template <> struct VSub4<uint, uint> : binary_function<uint, uint, uint>
@@ -725,19 +725,19 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VSub4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VSub4<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VSub2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VSub2<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< SubMat<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::SubMat<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -908,7 +908,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // mulMat
 
-namespace
+namespace arithm
 {
     struct Mul_8uc4_32f : binary_function<uint, float, uint>
     {
@@ -966,15 +966,15 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits<Mul_8uc4_32f> : ArithmFuncTraits<sizeof(uint), sizeof(uint)>
+    template <> struct TransformFunctorTraits<arithm::Mul_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
     {
     };
 
-    template <typename T, typename D> struct TransformFunctorTraits< Mul<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::Mul<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
-    template <typename T, typename S, typename D> struct TransformFunctorTraits< MulScale<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::MulScale<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -1066,7 +1066,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // mulScalar
 
-namespace
+namespace arithm
 {
     template <typename T, typename S, typename D> struct MulScalar : unary_function<T, D>
     {
@@ -1083,7 +1083,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename S, typename D> struct TransformFunctorTraits< MulScalar<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::MulScalar<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -1157,7 +1157,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // divMat
 
-namespace
+namespace arithm
 {
     struct Div_8uc4_32f : binary_function<uint, float, uint>
     {
@@ -1234,15 +1234,15 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits<Div_8uc4_32f> : ArithmFuncTraits<sizeof(uint), sizeof(uint)>
+    template <> struct TransformFunctorTraits<arithm::Div_8uc4_32f> : arithm::ArithmFuncTraits<sizeof(uint), sizeof(uint)>
     {
     };
 
-    template <typename T, typename D> struct TransformFunctorTraits< Div<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::Div<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
-    template <typename T, typename S, typename D> struct TransformFunctorTraits< DivScale<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::DivScale<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -1403,7 +1403,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // divInv
 
-namespace
+namespace arithm
 {
     template <typename T, typename S, typename D> struct DivInv : unary_function<T, D>
     {
@@ -1420,7 +1420,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename S, typename D> struct TransformFunctorTraits< DivInv<T, S, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename S, typename D> struct TransformFunctorTraits< arithm::DivInv<T, S, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 }}}
@@ -1494,7 +1494,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // absDiffMat
 
-namespace
+namespace arithm
 {
     template <typename T, typename D> struct VAbsDiff4;
     template <> struct VAbsDiff4<uint, uint> : binary_function<uint, uint, uint>
@@ -1611,19 +1611,19 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff4<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VAbsDiff4<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T, typename D> struct TransformFunctorTraits< VAbsDiff2<T, D> > : ArithmFuncTraits<sizeof(T), sizeof(D)>
+    template <typename T, typename D> struct TransformFunctorTraits< arithm::VAbsDiff2<T, D> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(D)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< AbsDiffMat<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::AbsDiffMat<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1666,7 +1666,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // absDiffScalar
 
-namespace
+namespace arithm
 {
     template <typename T, typename S> struct AbsDiffScalar : unary_function<T, T>
     {
@@ -1684,7 +1684,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T, typename S> struct TransformFunctorTraits< AbsDiffScalar<T, S> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T, typename S> struct TransformFunctorTraits< arithm::AbsDiffScalar<T, S> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1713,7 +1713,7 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< abs_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< abs_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1738,7 +1738,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // sqrMat
 
-namespace
+namespace arithm
 {
     template <typename T> struct Sqr : unary_function<T, T>
     {
@@ -1754,7 +1754,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< Sqr<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::Sqr<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1781,7 +1781,7 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< sqrt_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< sqrt_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1808,7 +1808,7 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< log_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< log_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1833,7 +1833,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // expMat
 
-namespace
+namespace arithm
 {
     template <typename T> struct Exp : unary_function<T, T>
     {
@@ -1850,7 +1850,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< Exp<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::Exp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -1875,7 +1875,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////////////////
 // cmpMat
 
-namespace
+namespace arithm
 {
     template <class Op, typename T>
     struct Cmp : binary_function<T, T, uchar>
@@ -1890,7 +1890,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <class Op, typename T> struct TransformFunctorTraits< Cmp<Op, T> > : ArithmFuncTraits<sizeof(T), sizeof(uchar)>
+    template <class Op, typename T> struct TransformFunctorTraits< arithm::Cmp<Op, T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(uchar)>
     {
     };
 }}}
@@ -1957,7 +1957,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////////////////
 // cmpScalar
 
-namespace
+namespace arithm
 {
 #define TYPE_VEC(type, cn) typename TypeVec<type, cn>::vec_type
 
@@ -2020,7 +2020,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <class Op, typename T> struct TransformFunctorTraits< CmpScalar<Op, T, 1> > : ArithmFuncTraits<sizeof(T), sizeof(uchar)>
+    template <class Op, typename T> struct TransformFunctorTraits< arithm::CmpScalar<Op, T, 1> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(uchar)>
     {
     };
 }}}
@@ -2179,19 +2179,19 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< bit_not<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< bit_not<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< bit_and<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< bit_and<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< bit_or<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< bit_or<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< bit_xor<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< bit_xor<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2252,15 +2252,15 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< binder2nd< bit_and<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_and<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< binder2nd< bit_or<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_or<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< binder2nd< bit_xor<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< binder2nd< bit_xor<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2298,7 +2298,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // min
 
-namespace
+namespace arithm
 {
     template <typename T> struct VMin4;
     template <> struct VMin4<uint> : binary_function<uint, uint, uint>
@@ -2389,23 +2389,23 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< VMin4<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::VMin4<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< VMin2<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::VMin2<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< minimum<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< minimum<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< binder2nd< minimum<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< binder2nd< minimum<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2458,7 +2458,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // max
 
-namespace
+namespace arithm
 {
     template <typename T> struct VMax4;
     template <> struct VMax4<uint> : binary_function<uint, uint, uint>
@@ -2549,23 +2549,23 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< VMax4<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::VMax4<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< VMax2<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::VMax2<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
     ////////////////////////////////////
 
-    template <typename T> struct TransformFunctorTraits< maximum<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< maximum<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< binder2nd< maximum<T> > > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< binder2nd< maximum<T> > > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2620,23 +2620,23 @@ namespace arithm
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< thresh_binary_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< thresh_binary_inv_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< thresh_binary_inv_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< thresh_trunc_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< thresh_trunc_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< thresh_to_zero_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 
-    template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< thresh_to_zero_inv_func<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2679,7 +2679,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // pow
 
-namespace
+namespace arithm
 {
     template<typename T, bool Signed = numeric_limits<T>::is_signed> struct PowOp : unary_function<T, T>
     {
@@ -2734,7 +2734,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T> struct TransformFunctorTraits< PowOp<T> > : ArithmFuncTraits<sizeof(T), sizeof(T)>
+    template <typename T> struct TransformFunctorTraits< arithm::PowOp<T> > : arithm::ArithmFuncTraits<sizeof(T), sizeof(T)>
     {
     };
 }}}
@@ -2759,7 +2759,7 @@ namespace arithm
 //////////////////////////////////////////////////////////////////////////
 // addWeighted
 
-namespace
+namespace arithm
 {
     template <typename T> struct UseDouble_
     {
@@ -2809,14 +2809,14 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <typename T1, typename T2, typename D, size_t src1_size, size_t src2_size, size_t dst_size> struct AddWeightedTraits : DefaultTransformFunctorTraits< AddWeighted<T1, T2, D> >
+    template <typename T1, typename T2, typename D, size_t src1_size, size_t src2_size, size_t dst_size> struct AddWeightedTraits : DefaultTransformFunctorTraits< arithm::AddWeighted<T1, T2, D> >
     {
     };
-    template <typename T1, typename T2, typename D, size_t src_size, size_t dst_size> struct AddWeightedTraits<T1, T2, D, src_size, src_size, dst_size> : ArithmFuncTraits<src_size, dst_size>
+    template <typename T1, typename T2, typename D, size_t src_size, size_t dst_size> struct AddWeightedTraits<T1, T2, D, src_size, src_size, dst_size> : arithm::ArithmFuncTraits<src_size, dst_size>
     {
     };
 
-    template <typename T1, typename T2, typename D> struct TransformFunctorTraits< AddWeighted<T1, T2, D> > : AddWeightedTraits<T1, T2, D, sizeof(T1), sizeof(T2), sizeof(D)>
+    template <typename T1, typename T2, typename D> struct TransformFunctorTraits< arithm::AddWeighted<T1, T2, D> > : AddWeightedTraits<T1, T2, D, sizeof(T1), sizeof(T2), sizeof(D)>
     {
     };
 }}}
diff --git a/modules/gpu/src/cuda/gftt.cu b/modules/gpu/src/cuda/gftt.cu
index 4c21bd911..cae217e39 100644
--- a/modules/gpu/src/cuda/gftt.cu
+++ b/modules/gpu/src/cuda/gftt.cu
@@ -47,6 +47,7 @@
 
 #if !defined CUDA_DISABLER
 
+#include <thrust/device_ptr.h>
 #include <thrust/sort.h>
 
 #include "opencv2/gpu/device/common.hpp"
@@ -148,4 +149,4 @@ namespace cv { namespace gpu { namespace device
 }}}
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/global_motion.cu b/modules/gpu/src/cuda/global_motion.cu
index c48274a41..2af56568d 100644
--- a/modules/gpu/src/cuda/global_motion.cu
+++ b/modules/gpu/src/cuda/global_motion.cu
@@ -43,12 +43,11 @@
 
 #if !defined CUDA_DISABLER
 
-#include "thrust/device_ptr.h"
-#include "thrust/remove.h"
-#include "thrust/functional.h"
-#include "internal_shared.hpp"
+#include <thrust/device_ptr.h>
+#include <thrust/remove.h>
+#include <thrust/functional.h>
 
-using namespace thrust;
+#include "internal_shared.hpp"
 
 namespace cv { namespace gpu { namespace device { namespace globmotion {
 
@@ -64,7 +63,7 @@ int compactPoints(int N, float *points0, float *points1, const uchar *mask)
     return thrust::remove_if(thrust::make_zip_iterator(thrust::make_tuple(dpoints0, dpoints1)),
                              thrust::make_zip_iterator(thrust::make_tuple(dpoints0 + N, dpoints1 + N)),
                              dmask, thrust::not1(thrust::identity<uchar>()))
-           - make_zip_iterator(make_tuple(dpoints0, dpoints1));
+           - thrust::make_zip_iterator(make_tuple(dpoints0, dpoints1));
 }
 
 
@@ -117,4 +116,4 @@ void calcWobbleSuppressionMaps(
 }}}}
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/hist.cu b/modules/gpu/src/cuda/hist.cu
index 2adc5d5b4..9dd14182b 100644
--- a/modules/gpu/src/cuda/hist.cu
+++ b/modules/gpu/src/cuda/hist.cu
@@ -51,9 +51,9 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace hist
 {
-    __global__ void histogram256(const uchar* src, int cols, int rows, size_t step, int* hist)
+    __global__ void histogram256Kernel(const uchar* src, int cols, int rows, size_t step, int* hist)
     {
         __shared__ int shist[256];
 
@@ -94,16 +94,13 @@ namespace
         if (histVal > 0)
             ::atomicAdd(hist + tid, histVal);
     }
-}
 
-namespace hist
-{
     void histogram256(PtrStepSzb src, int* hist, cudaStream_t stream)
     {
         const dim3 block(32, 8);
         const dim3 grid(divUp(src.rows, block.y));
 
-        ::histogram256<<<grid, block, 0, stream>>>(src.data, src.cols, src.rows, src.step, hist);
+        histogram256Kernel<<<grid, block, 0, stream>>>(src.data, src.cols, src.rows, src.step, hist);
         cudaSafeCall( cudaGetLastError() );
 
         if (stream == 0)
@@ -113,7 +110,7 @@ namespace hist
 
 /////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace hist
 {
     __constant__ int c_lut[256];
 
@@ -133,7 +130,7 @@ namespace
 
 namespace cv { namespace gpu { namespace device
 {
-    template <> struct TransformFunctorTraits<EqualizeHist> : DefaultTransformFunctorTraits<EqualizeHist>
+    template <> struct TransformFunctorTraits<hist::EqualizeHist> : DefaultTransformFunctorTraits<hist::EqualizeHist>
     {
         enum { smart_shift = 4 };
     };
diff --git a/modules/gpu/src/cuda/hog.cu b/modules/gpu/src/cuda/hog.cu
index 6a7e927d1..523e5bf64 100644
--- a/modules/gpu/src/cuda/hog.cu
+++ b/modules/gpu/src/cuda/hog.cu
@@ -244,15 +244,17 @@ namespace cv { namespace gpu { namespace device
                 return smem[0];
             #endif
             }
+            else
+            {
+            #if __CUDA_ARCH__ >= 300
+                if (threadIdx.x == 0)
+                    smem[0] = sum;
+            #endif
 
-        #if __CUDA_ARCH__ >= 300
-            if (threadIdx.x == 0)
-                smem[0] = sum;
-        #endif
+                __syncthreads();
 
-            __syncthreads();
-
-            return smem[0];
+                return smem[0];
+            }
         }
 
 
diff --git a/modules/gpu/src/cuda/hough.cu b/modules/gpu/src/cuda/hough.cu
index 4835e3568..c4dfbcb66 100644
--- a/modules/gpu/src/cuda/hough.cu
+++ b/modules/gpu/src/cuda/hough.cu
@@ -42,7 +42,9 @@
 
 #if !defined CUDA_DISABLER
 
+#include <thrust/device_ptr.h>
 #include <thrust/sort.h>
+
 #include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/emulation.hpp"
 #include "opencv2/gpu/device/vec_math.hpp"
diff --git a/modules/gpu/src/cuda/matrix_reductions.cu b/modules/gpu/src/cuda/matrix_reductions.cu
index 7a0e8d2fe..d34b38a25 100644
--- a/modules/gpu/src/cuda/matrix_reductions.cu
+++ b/modules/gpu/src/cuda/matrix_reductions.cu
@@ -55,7 +55,7 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace detail
 {
     template <int cn> struct Unroll;
     template <> struct Unroll<1>
@@ -218,7 +218,7 @@ namespace sum
             {
                 sum = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<result_type>::all(0);
 
-                device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<R>()));
+                device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
 
                 if (tid == 0)
                 {
@@ -254,7 +254,7 @@ namespace sum
             {
                 sum = tid < gridDim.x * gridDim.y ? result[tid] : VecTraits<result_type>::all(0);
 
-                device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<double>()));
+                device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<double>()));
 
                 if (tid == 0)
                 {
@@ -294,7 +294,7 @@ namespace sum
             }
         }
 
-        device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(sum), tid, Unroll<cn>::op(plus<R>()));
+        device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(sum), tid, detail::Unroll<cn>::op(plus<R>()));
 
         GlobalReduce<BLOCK_SIZE, R, cn>::run(sum, result, tid, bid, smem);
     }
@@ -918,13 +918,11 @@ namespace countNonZero
     __global__ void kernel(const PtrStepSz<T> src, unsigned int* count, const int twidth, const int theight)
     {
         __shared__ unsigned int scount[BLOCK_SIZE];
-        __shared__ bool is_last;
 
         const int x0 = blockIdx.x * blockDim.x * twidth + threadIdx.x;
         const int y0 = blockIdx.y * blockDim.y * theight + threadIdx.y;
 
         const int tid = threadIdx.y * blockDim.x + threadIdx.x;
-        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
 
         unsigned int mycount = 0;
 
@@ -946,6 +944,9 @@ namespace countNonZero
         if (tid == 0)
             ::atomicAdd(count, mycount);
     #else
+        __shared__ bool is_last;
+        const int bid = blockIdx.y * gridDim.x + blockIdx.x;
+
         if (tid == 0)
         {
             count[bid] = mycount;
@@ -1244,7 +1245,7 @@ namespace reduce
         for (int x = threadIdx.x; x < src.cols; x += BLOCK_SIZE)
             myVal = op(myVal, saturate_cast<work_type>(srcRow[x]));
 
-        device::reduce<BLOCK_SIZE>(Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), Unroll<cn>::tie(myVal), threadIdx.x, Unroll<cn>::op(op));
+        device::reduce<BLOCK_SIZE>(detail::Unroll<cn>::template smem_tuple<BLOCK_SIZE>(smem), detail::Unroll<cn>::tie(myVal), threadIdx.x, detail::Unroll<cn>::op(op));
 
         if (threadIdx.x == 0)
             dst[y] = saturate_cast<dst_type>(op.result(myVal, src.cols));
diff --git a/modules/gpu/src/cuda/optflowbm.cu b/modules/gpu/src/cuda/optflowbm.cu
index e924170fc..7e4acd900 100644
--- a/modules/gpu/src/cuda/optflowbm.cu
+++ b/modules/gpu/src/cuda/optflowbm.cu
@@ -48,7 +48,7 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace optflowbm
 {
     texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_prev(false, cudaFilterModePoint, cudaAddressModeClamp);
     texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_curr(false, cudaFilterModePoint, cudaAddressModeClamp);
@@ -145,10 +145,7 @@ namespace
         velx(i, j) = static_cast<float>(sumx) / countMin;
         vely(i, j) = static_cast<float>(sumy) / countMin;
     }
-}
 
-namespace optflowbm
-{
     void calc(PtrStepSzb prev, PtrStepSzb curr, PtrStepSzf velx, PtrStepSzf vely, int2 blockSize, int2 shiftSize, bool usePrevious,
               int maxX, int maxY, int acceptLevel, int escapeLevel, const short2* ss, int ssCount, cudaStream_t stream)
     {
diff --git a/modules/gpu/src/cuda/orb.cu b/modules/gpu/src/cuda/orb.cu
index d66b3e9ec..95706dfa3 100644
--- a/modules/gpu/src/cuda/orb.cu
+++ b/modules/gpu/src/cuda/orb.cu
@@ -47,6 +47,7 @@
 
 #if !defined CUDA_DISABLER
 
+#include <thrust/device_ptr.h>
 #include <thrust/sort.h>
 
 #include "opencv2/gpu/device/common.hpp"
diff --git a/modules/gpu/src/cuda/pyrlk.cu b/modules/gpu/src/cuda/pyrlk.cu
index c0f54bd33..8d746143c 100644
--- a/modules/gpu/src/cuda/pyrlk.cu
+++ b/modules/gpu/src/cuda/pyrlk.cu
@@ -57,7 +57,7 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace pyrlk
 {
     __constant__ int c_winSize_x;
     __constant__ int c_winSize_y;
@@ -123,7 +123,7 @@ namespace
     }
 
     template <int cn, int PATCH_X, int PATCH_Y, bool calcErr>
-    __global__ void sparse(const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)
+    __global__ void sparseKernel(const float2* prevPts, float2* nextPts, uchar* status, float* err, const int level, const int rows, const int cols)
     {
     #if __CUDA_ARCH__ <= 110
         const int BLOCK_SIZE = 128;
@@ -321,9 +321,9 @@ namespace
         dim3 grid(ptcount);
 
         if (level == 0 && err)
-            sparse<cn, PATCH_X, PATCH_Y, true><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
+            sparseKernel<cn, PATCH_X, PATCH_Y, true><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
         else
-            sparse<cn, PATCH_X, PATCH_Y, false><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
+            sparseKernel<cn, PATCH_X, PATCH_Y, false><<<grid, block>>>(prevPts, nextPts, status, err, level, rows, cols);
 
         cudaSafeCall( cudaGetLastError() );
 
@@ -332,7 +332,7 @@ namespace
     }
 
     template <bool calcErr>
-    __global__ void dense(PtrStepf u, PtrStepf v, const PtrStepf prevU, const PtrStepf prevV, PtrStepf err, const int rows, const int cols)
+    __global__ void denseKernel(PtrStepf u, PtrStepf v, const PtrStepf prevU, const PtrStepf prevV, PtrStepf err, const int rows, const int cols)
     {
         extern __shared__ int smem[];
 
@@ -476,10 +476,7 @@ namespace
             err(y, x) = static_cast<float>(errval) / (c_winSize_x * c_winSize_y);
         }
     }
-}
 
-namespace pyrlk
-{
     void loadConstants(int2 winSize, int iters)
     {
         cudaSafeCall( cudaMemcpyToSymbol(c_winSize_x, &winSize.x, sizeof(int)) );
@@ -500,11 +497,11 @@ namespace pyrlk
 
         static const func_t funcs[5][5] =
         {
-            {::sparse_caller<1, 1, 1>, ::sparse_caller<1, 2, 1>, ::sparse_caller<1, 3, 1>, ::sparse_caller<1, 4, 1>, ::sparse_caller<1, 5, 1>},
-            {::sparse_caller<1, 1, 2>, ::sparse_caller<1, 2, 2>, ::sparse_caller<1, 3, 2>, ::sparse_caller<1, 4, 2>, ::sparse_caller<1, 5, 2>},
-            {::sparse_caller<1, 1, 3>, ::sparse_caller<1, 2, 3>, ::sparse_caller<1, 3, 3>, ::sparse_caller<1, 4, 3>, ::sparse_caller<1, 5, 3>},
-            {::sparse_caller<1, 1, 4>, ::sparse_caller<1, 2, 4>, ::sparse_caller<1, 3, 4>, ::sparse_caller<1, 4, 4>, ::sparse_caller<1, 5, 4>},
-            {::sparse_caller<1, 1, 5>, ::sparse_caller<1, 2, 5>, ::sparse_caller<1, 3, 5>, ::sparse_caller<1, 4, 5>, ::sparse_caller<1, 5, 5>}
+            {sparse_caller<1, 1, 1>, sparse_caller<1, 2, 1>, sparse_caller<1, 3, 1>, sparse_caller<1, 4, 1>, sparse_caller<1, 5, 1>},
+            {sparse_caller<1, 1, 2>, sparse_caller<1, 2, 2>, sparse_caller<1, 3, 2>, sparse_caller<1, 4, 2>, sparse_caller<1, 5, 2>},
+            {sparse_caller<1, 1, 3>, sparse_caller<1, 2, 3>, sparse_caller<1, 3, 3>, sparse_caller<1, 4, 3>, sparse_caller<1, 5, 3>},
+            {sparse_caller<1, 1, 4>, sparse_caller<1, 2, 4>, sparse_caller<1, 3, 4>, sparse_caller<1, 4, 4>, sparse_caller<1, 5, 4>},
+            {sparse_caller<1, 1, 5>, sparse_caller<1, 2, 5>, sparse_caller<1, 3, 5>, sparse_caller<1, 4, 5>, sparse_caller<1, 5, 5>}
         };
 
         bindTexture(&tex_If, I);
@@ -522,11 +519,11 @@ namespace pyrlk
 
         static const func_t funcs[5][5] =
         {
-            {::sparse_caller<4, 1, 1>, ::sparse_caller<4, 2, 1>, ::sparse_caller<4, 3, 1>, ::sparse_caller<4, 4, 1>, ::sparse_caller<4, 5, 1>},
-            {::sparse_caller<4, 1, 2>, ::sparse_caller<4, 2, 2>, ::sparse_caller<4, 3, 2>, ::sparse_caller<4, 4, 2>, ::sparse_caller<4, 5, 2>},
-            {::sparse_caller<4, 1, 3>, ::sparse_caller<4, 2, 3>, ::sparse_caller<4, 3, 3>, ::sparse_caller<4, 4, 3>, ::sparse_caller<4, 5, 3>},
-            {::sparse_caller<4, 1, 4>, ::sparse_caller<4, 2, 4>, ::sparse_caller<4, 3, 4>, ::sparse_caller<4, 4, 4>, ::sparse_caller<4, 5, 4>},
-            {::sparse_caller<4, 1, 5>, ::sparse_caller<4, 2, 5>, ::sparse_caller<4, 3, 5>, ::sparse_caller<4, 4, 5>, ::sparse_caller<4, 5, 5>}
+            {sparse_caller<4, 1, 1>, sparse_caller<4, 2, 1>, sparse_caller<4, 3, 1>, sparse_caller<4, 4, 1>, sparse_caller<4, 5, 1>},
+            {sparse_caller<4, 1, 2>, sparse_caller<4, 2, 2>, sparse_caller<4, 3, 2>, sparse_caller<4, 4, 2>, sparse_caller<4, 5, 2>},
+            {sparse_caller<4, 1, 3>, sparse_caller<4, 2, 3>, sparse_caller<4, 3, 3>, sparse_caller<4, 4, 3>, sparse_caller<4, 5, 3>},
+            {sparse_caller<4, 1, 4>, sparse_caller<4, 2, 4>, sparse_caller<4, 3, 4>, sparse_caller<4, 4, 4>, sparse_caller<4, 5, 4>},
+            {sparse_caller<4, 1, 5>, sparse_caller<4, 2, 5>, sparse_caller<4, 3, 5>, sparse_caller<4, 4, 5>, sparse_caller<4, 5, 5>}
         };
 
         bindTexture(&tex_If4, I);
@@ -551,12 +548,12 @@ namespace pyrlk
 
         if (err.data)
         {
-            ::dense<true><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, err, I.rows, I.cols);
+            denseKernel<true><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, err, I.rows, I.cols);
             cudaSafeCall( cudaGetLastError() );
         }
         else
         {
-            ::dense<false><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, PtrStepf(), I.rows, I.cols);
+            denseKernel<false><<<grid, block, smem_size, stream>>>(u, v, prevU, prevV, PtrStepf(), I.rows, I.cols);
             cudaSafeCall( cudaGetLastError() );
         }
 
diff --git a/modules/gpu/src/cuda/row_filter.h b/modules/gpu/src/cuda/row_filter.h
index 0da2dfe0c..f2da684cc 100644
--- a/modules/gpu/src/cuda/row_filter.h
+++ b/modules/gpu/src/cuda/row_filter.h
@@ -49,20 +49,12 @@
 using namespace cv::gpu;
 using namespace cv::gpu::device;
 
-namespace
+namespace row_filter
 {
     #define MAX_KERNEL_SIZE 32
 
     __constant__ float c_kernel[MAX_KERNEL_SIZE];
 
-    void loadKernel(const float* kernel, int ksize, cudaStream_t stream)
-    {
-        if (stream == 0)
-            cudaSafeCall( cudaMemcpyToSymbol(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
-        else
-            cudaSafeCall( cudaMemcpyToSymbolAsync(c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
-    }
-
     template <int KSIZE, typename T, typename D, typename B>
     __global__ void linearRowFilter(const PtrStepSz<T> src, PtrStep<D> dst, const int anchor, const B brd)
     {
@@ -195,182 +187,185 @@ namespace filter
         {
             {
                 0,
-                ::caller< 1, T, D, BrdRowReflect101>,
-                ::caller< 2, T, D, BrdRowReflect101>,
-                ::caller< 3, T, D, BrdRowReflect101>,
-                ::caller< 4, T, D, BrdRowReflect101>,
-                ::caller< 5, T, D, BrdRowReflect101>,
-                ::caller< 6, T, D, BrdRowReflect101>,
-                ::caller< 7, T, D, BrdRowReflect101>,
-                ::caller< 8, T, D, BrdRowReflect101>,
-                ::caller< 9, T, D, BrdRowReflect101>,
-                ::caller<10, T, D, BrdRowReflect101>,
-                ::caller<11, T, D, BrdRowReflect101>,
-                ::caller<12, T, D, BrdRowReflect101>,
-                ::caller<13, T, D, BrdRowReflect101>,
-                ::caller<14, T, D, BrdRowReflect101>,
-                ::caller<15, T, D, BrdRowReflect101>,
-                ::caller<16, T, D, BrdRowReflect101>,
-                ::caller<17, T, D, BrdRowReflect101>,
-                ::caller<18, T, D, BrdRowReflect101>,
-                ::caller<19, T, D, BrdRowReflect101>,
-                ::caller<20, T, D, BrdRowReflect101>,
-                ::caller<21, T, D, BrdRowReflect101>,
-                ::caller<22, T, D, BrdRowReflect101>,
-                ::caller<23, T, D, BrdRowReflect101>,
-                ::caller<24, T, D, BrdRowReflect101>,
-                ::caller<25, T, D, BrdRowReflect101>,
-                ::caller<26, T, D, BrdRowReflect101>,
-                ::caller<27, T, D, BrdRowReflect101>,
-                ::caller<28, T, D, BrdRowReflect101>,
-                ::caller<29, T, D, BrdRowReflect101>,
-                ::caller<30, T, D, BrdRowReflect101>,
-                ::caller<31, T, D, BrdRowReflect101>,
-                ::caller<32, T, D, BrdRowReflect101>
+                row_filter::caller< 1, T, D, BrdRowReflect101>,
+                row_filter::caller< 2, T, D, BrdRowReflect101>,
+                row_filter::caller< 3, T, D, BrdRowReflect101>,
+                row_filter::caller< 4, T, D, BrdRowReflect101>,
+                row_filter::caller< 5, T, D, BrdRowReflect101>,
+                row_filter::caller< 6, T, D, BrdRowReflect101>,
+                row_filter::caller< 7, T, D, BrdRowReflect101>,
+                row_filter::caller< 8, T, D, BrdRowReflect101>,
+                row_filter::caller< 9, T, D, BrdRowReflect101>,
+                row_filter::caller<10, T, D, BrdRowReflect101>,
+                row_filter::caller<11, T, D, BrdRowReflect101>,
+                row_filter::caller<12, T, D, BrdRowReflect101>,
+                row_filter::caller<13, T, D, BrdRowReflect101>,
+                row_filter::caller<14, T, D, BrdRowReflect101>,
+                row_filter::caller<15, T, D, BrdRowReflect101>,
+                row_filter::caller<16, T, D, BrdRowReflect101>,
+                row_filter::caller<17, T, D, BrdRowReflect101>,
+                row_filter::caller<18, T, D, BrdRowReflect101>,
+                row_filter::caller<19, T, D, BrdRowReflect101>,
+                row_filter::caller<20, T, D, BrdRowReflect101>,
+                row_filter::caller<21, T, D, BrdRowReflect101>,
+                row_filter::caller<22, T, D, BrdRowReflect101>,
+                row_filter::caller<23, T, D, BrdRowReflect101>,
+                row_filter::caller<24, T, D, BrdRowReflect101>,
+                row_filter::caller<25, T, D, BrdRowReflect101>,
+                row_filter::caller<26, T, D, BrdRowReflect101>,
+                row_filter::caller<27, T, D, BrdRowReflect101>,
+                row_filter::caller<28, T, D, BrdRowReflect101>,
+                row_filter::caller<29, T, D, BrdRowReflect101>,
+                row_filter::caller<30, T, D, BrdRowReflect101>,
+                row_filter::caller<31, T, D, BrdRowReflect101>,
+                row_filter::caller<32, T, D, BrdRowReflect101>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdRowReplicate>,
-                ::caller< 2, T, D, BrdRowReplicate>,
-                ::caller< 3, T, D, BrdRowReplicate>,
-                ::caller< 4, T, D, BrdRowReplicate>,
-                ::caller< 5, T, D, BrdRowReplicate>,
-                ::caller< 6, T, D, BrdRowReplicate>,
-                ::caller< 7, T, D, BrdRowReplicate>,
-                ::caller< 8, T, D, BrdRowReplicate>,
-                ::caller< 9, T, D, BrdRowReplicate>,
-                ::caller<10, T, D, BrdRowReplicate>,
-                ::caller<11, T, D, BrdRowReplicate>,
-                ::caller<12, T, D, BrdRowReplicate>,
-                ::caller<13, T, D, BrdRowReplicate>,
-                ::caller<14, T, D, BrdRowReplicate>,
-                ::caller<15, T, D, BrdRowReplicate>,
-                ::caller<16, T, D, BrdRowReplicate>,
-                ::caller<17, T, D, BrdRowReplicate>,
-                ::caller<18, T, D, BrdRowReplicate>,
-                ::caller<19, T, D, BrdRowReplicate>,
-                ::caller<20, T, D, BrdRowReplicate>,
-                ::caller<21, T, D, BrdRowReplicate>,
-                ::caller<22, T, D, BrdRowReplicate>,
-                ::caller<23, T, D, BrdRowReplicate>,
-                ::caller<24, T, D, BrdRowReplicate>,
-                ::caller<25, T, D, BrdRowReplicate>,
-                ::caller<26, T, D, BrdRowReplicate>,
-                ::caller<27, T, D, BrdRowReplicate>,
-                ::caller<28, T, D, BrdRowReplicate>,
-                ::caller<29, T, D, BrdRowReplicate>,
-                ::caller<30, T, D, BrdRowReplicate>,
-                ::caller<31, T, D, BrdRowReplicate>,
-                ::caller<32, T, D, BrdRowReplicate>
+                row_filter::caller< 1, T, D, BrdRowReplicate>,
+                row_filter::caller< 2, T, D, BrdRowReplicate>,
+                row_filter::caller< 3, T, D, BrdRowReplicate>,
+                row_filter::caller< 4, T, D, BrdRowReplicate>,
+                row_filter::caller< 5, T, D, BrdRowReplicate>,
+                row_filter::caller< 6, T, D, BrdRowReplicate>,
+                row_filter::caller< 7, T, D, BrdRowReplicate>,
+                row_filter::caller< 8, T, D, BrdRowReplicate>,
+                row_filter::caller< 9, T, D, BrdRowReplicate>,
+                row_filter::caller<10, T, D, BrdRowReplicate>,
+                row_filter::caller<11, T, D, BrdRowReplicate>,
+                row_filter::caller<12, T, D, BrdRowReplicate>,
+                row_filter::caller<13, T, D, BrdRowReplicate>,
+                row_filter::caller<14, T, D, BrdRowReplicate>,
+                row_filter::caller<15, T, D, BrdRowReplicate>,
+                row_filter::caller<16, T, D, BrdRowReplicate>,
+                row_filter::caller<17, T, D, BrdRowReplicate>,
+                row_filter::caller<18, T, D, BrdRowReplicate>,
+                row_filter::caller<19, T, D, BrdRowReplicate>,
+                row_filter::caller<20, T, D, BrdRowReplicate>,
+                row_filter::caller<21, T, D, BrdRowReplicate>,
+                row_filter::caller<22, T, D, BrdRowReplicate>,
+                row_filter::caller<23, T, D, BrdRowReplicate>,
+                row_filter::caller<24, T, D, BrdRowReplicate>,
+                row_filter::caller<25, T, D, BrdRowReplicate>,
+                row_filter::caller<26, T, D, BrdRowReplicate>,
+                row_filter::caller<27, T, D, BrdRowReplicate>,
+                row_filter::caller<28, T, D, BrdRowReplicate>,
+                row_filter::caller<29, T, D, BrdRowReplicate>,
+                row_filter::caller<30, T, D, BrdRowReplicate>,
+                row_filter::caller<31, T, D, BrdRowReplicate>,
+                row_filter::caller<32, T, D, BrdRowReplicate>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdRowConstant>,
-                ::caller< 2, T, D, BrdRowConstant>,
-                ::caller< 3, T, D, BrdRowConstant>,
-                ::caller< 4, T, D, BrdRowConstant>,
-                ::caller< 5, T, D, BrdRowConstant>,
-                ::caller< 6, T, D, BrdRowConstant>,
-                ::caller< 7, T, D, BrdRowConstant>,
-                ::caller< 8, T, D, BrdRowConstant>,
-                ::caller< 9, T, D, BrdRowConstant>,
-                ::caller<10, T, D, BrdRowConstant>,
-                ::caller<11, T, D, BrdRowConstant>,
-                ::caller<12, T, D, BrdRowConstant>,
-                ::caller<13, T, D, BrdRowConstant>,
-                ::caller<14, T, D, BrdRowConstant>,
-                ::caller<15, T, D, BrdRowConstant>,
-                ::caller<16, T, D, BrdRowConstant>,
-                ::caller<17, T, D, BrdRowConstant>,
-                ::caller<18, T, D, BrdRowConstant>,
-                ::caller<19, T, D, BrdRowConstant>,
-                ::caller<20, T, D, BrdRowConstant>,
-                ::caller<21, T, D, BrdRowConstant>,
-                ::caller<22, T, D, BrdRowConstant>,
-                ::caller<23, T, D, BrdRowConstant>,
-                ::caller<24, T, D, BrdRowConstant>,
-                ::caller<25, T, D, BrdRowConstant>,
-                ::caller<26, T, D, BrdRowConstant>,
-                ::caller<27, T, D, BrdRowConstant>,
-                ::caller<28, T, D, BrdRowConstant>,
-                ::caller<29, T, D, BrdRowConstant>,
-                ::caller<30, T, D, BrdRowConstant>,
-                ::caller<31, T, D, BrdRowConstant>,
-                ::caller<32, T, D, BrdRowConstant>
+                row_filter::caller< 1, T, D, BrdRowConstant>,
+                row_filter::caller< 2, T, D, BrdRowConstant>,
+                row_filter::caller< 3, T, D, BrdRowConstant>,
+                row_filter::caller< 4, T, D, BrdRowConstant>,
+                row_filter::caller< 5, T, D, BrdRowConstant>,
+                row_filter::caller< 6, T, D, BrdRowConstant>,
+                row_filter::caller< 7, T, D, BrdRowConstant>,
+                row_filter::caller< 8, T, D, BrdRowConstant>,
+                row_filter::caller< 9, T, D, BrdRowConstant>,
+                row_filter::caller<10, T, D, BrdRowConstant>,
+                row_filter::caller<11, T, D, BrdRowConstant>,
+                row_filter::caller<12, T, D, BrdRowConstant>,
+                row_filter::caller<13, T, D, BrdRowConstant>,
+                row_filter::caller<14, T, D, BrdRowConstant>,
+                row_filter::caller<15, T, D, BrdRowConstant>,
+                row_filter::caller<16, T, D, BrdRowConstant>,
+                row_filter::caller<17, T, D, BrdRowConstant>,
+                row_filter::caller<18, T, D, BrdRowConstant>,
+                row_filter::caller<19, T, D, BrdRowConstant>,
+                row_filter::caller<20, T, D, BrdRowConstant>,
+                row_filter::caller<21, T, D, BrdRowConstant>,
+                row_filter::caller<22, T, D, BrdRowConstant>,
+                row_filter::caller<23, T, D, BrdRowConstant>,
+                row_filter::caller<24, T, D, BrdRowConstant>,
+                row_filter::caller<25, T, D, BrdRowConstant>,
+                row_filter::caller<26, T, D, BrdRowConstant>,
+                row_filter::caller<27, T, D, BrdRowConstant>,
+                row_filter::caller<28, T, D, BrdRowConstant>,
+                row_filter::caller<29, T, D, BrdRowConstant>,
+                row_filter::caller<30, T, D, BrdRowConstant>,
+                row_filter::caller<31, T, D, BrdRowConstant>,
+                row_filter::caller<32, T, D, BrdRowConstant>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdRowReflect>,
-                ::caller< 2, T, D, BrdRowReflect>,
-                ::caller< 3, T, D, BrdRowReflect>,
-                ::caller< 4, T, D, BrdRowReflect>,
-                ::caller< 5, T, D, BrdRowReflect>,
-                ::caller< 6, T, D, BrdRowReflect>,
-                ::caller< 7, T, D, BrdRowReflect>,
-                ::caller< 8, T, D, BrdRowReflect>,
-                ::caller< 9, T, D, BrdRowReflect>,
-                ::caller<10, T, D, BrdRowReflect>,
-                ::caller<11, T, D, BrdRowReflect>,
-                ::caller<12, T, D, BrdRowReflect>,
-                ::caller<13, T, D, BrdRowReflect>,
-                ::caller<14, T, D, BrdRowReflect>,
-                ::caller<15, T, D, BrdRowReflect>,
-                ::caller<16, T, D, BrdRowReflect>,
-                ::caller<17, T, D, BrdRowReflect>,
-                ::caller<18, T, D, BrdRowReflect>,
-                ::caller<19, T, D, BrdRowReflect>,
-                ::caller<20, T, D, BrdRowReflect>,
-                ::caller<21, T, D, BrdRowReflect>,
-                ::caller<22, T, D, BrdRowReflect>,
-                ::caller<23, T, D, BrdRowReflect>,
-                ::caller<24, T, D, BrdRowReflect>,
-                ::caller<25, T, D, BrdRowReflect>,
-                ::caller<26, T, D, BrdRowReflect>,
-                ::caller<27, T, D, BrdRowReflect>,
-                ::caller<28, T, D, BrdRowReflect>,
-                ::caller<29, T, D, BrdRowReflect>,
-                ::caller<30, T, D, BrdRowReflect>,
-                ::caller<31, T, D, BrdRowReflect>,
-                ::caller<32, T, D, BrdRowReflect>
+                row_filter::caller< 1, T, D, BrdRowReflect>,
+                row_filter::caller< 2, T, D, BrdRowReflect>,
+                row_filter::caller< 3, T, D, BrdRowReflect>,
+                row_filter::caller< 4, T, D, BrdRowReflect>,
+                row_filter::caller< 5, T, D, BrdRowReflect>,
+                row_filter::caller< 6, T, D, BrdRowReflect>,
+                row_filter::caller< 7, T, D, BrdRowReflect>,
+                row_filter::caller< 8, T, D, BrdRowReflect>,
+                row_filter::caller< 9, T, D, BrdRowReflect>,
+                row_filter::caller<10, T, D, BrdRowReflect>,
+                row_filter::caller<11, T, D, BrdRowReflect>,
+                row_filter::caller<12, T, D, BrdRowReflect>,
+                row_filter::caller<13, T, D, BrdRowReflect>,
+                row_filter::caller<14, T, D, BrdRowReflect>,
+                row_filter::caller<15, T, D, BrdRowReflect>,
+                row_filter::caller<16, T, D, BrdRowReflect>,
+                row_filter::caller<17, T, D, BrdRowReflect>,
+                row_filter::caller<18, T, D, BrdRowReflect>,
+                row_filter::caller<19, T, D, BrdRowReflect>,
+                row_filter::caller<20, T, D, BrdRowReflect>,
+                row_filter::caller<21, T, D, BrdRowReflect>,
+                row_filter::caller<22, T, D, BrdRowReflect>,
+                row_filter::caller<23, T, D, BrdRowReflect>,
+                row_filter::caller<24, T, D, BrdRowReflect>,
+                row_filter::caller<25, T, D, BrdRowReflect>,
+                row_filter::caller<26, T, D, BrdRowReflect>,
+                row_filter::caller<27, T, D, BrdRowReflect>,
+                row_filter::caller<28, T, D, BrdRowReflect>,
+                row_filter::caller<29, T, D, BrdRowReflect>,
+                row_filter::caller<30, T, D, BrdRowReflect>,
+                row_filter::caller<31, T, D, BrdRowReflect>,
+                row_filter::caller<32, T, D, BrdRowReflect>
             },
             {
                 0,
-                ::caller< 1, T, D, BrdRowWrap>,
-                ::caller< 2, T, D, BrdRowWrap>,
-                ::caller< 3, T, D, BrdRowWrap>,
-                ::caller< 4, T, D, BrdRowWrap>,
-                ::caller< 5, T, D, BrdRowWrap>,
-                ::caller< 6, T, D, BrdRowWrap>,
-                ::caller< 7, T, D, BrdRowWrap>,
-                ::caller< 8, T, D, BrdRowWrap>,
-                ::caller< 9, T, D, BrdRowWrap>,
-                ::caller<10, T, D, BrdRowWrap>,
-                ::caller<11, T, D, BrdRowWrap>,
-                ::caller<12, T, D, BrdRowWrap>,
-                ::caller<13, T, D, BrdRowWrap>,
-                ::caller<14, T, D, BrdRowWrap>,
-                ::caller<15, T, D, BrdRowWrap>,
-                ::caller<16, T, D, BrdRowWrap>,
-                ::caller<17, T, D, BrdRowWrap>,
-                ::caller<18, T, D, BrdRowWrap>,
-                ::caller<19, T, D, BrdRowWrap>,
-                ::caller<20, T, D, BrdRowWrap>,
-                ::caller<21, T, D, BrdRowWrap>,
-                ::caller<22, T, D, BrdRowWrap>,
-                ::caller<23, T, D, BrdRowWrap>,
-                ::caller<24, T, D, BrdRowWrap>,
-                ::caller<25, T, D, BrdRowWrap>,
-                ::caller<26, T, D, BrdRowWrap>,
-                ::caller<27, T, D, BrdRowWrap>,
-                ::caller<28, T, D, BrdRowWrap>,
-                ::caller<29, T, D, BrdRowWrap>,
-                ::caller<30, T, D, BrdRowWrap>,
-                ::caller<31, T, D, BrdRowWrap>,
-                ::caller<32, T, D, BrdRowWrap>
+                row_filter::caller< 1, T, D, BrdRowWrap>,
+                row_filter::caller< 2, T, D, BrdRowWrap>,
+                row_filter::caller< 3, T, D, BrdRowWrap>,
+                row_filter::caller< 4, T, D, BrdRowWrap>,
+                row_filter::caller< 5, T, D, BrdRowWrap>,
+                row_filter::caller< 6, T, D, BrdRowWrap>,
+                row_filter::caller< 7, T, D, BrdRowWrap>,
+                row_filter::caller< 8, T, D, BrdRowWrap>,
+                row_filter::caller< 9, T, D, BrdRowWrap>,
+                row_filter::caller<10, T, D, BrdRowWrap>,
+                row_filter::caller<11, T, D, BrdRowWrap>,
+                row_filter::caller<12, T, D, BrdRowWrap>,
+                row_filter::caller<13, T, D, BrdRowWrap>,
+                row_filter::caller<14, T, D, BrdRowWrap>,
+                row_filter::caller<15, T, D, BrdRowWrap>,
+                row_filter::caller<16, T, D, BrdRowWrap>,
+                row_filter::caller<17, T, D, BrdRowWrap>,
+                row_filter::caller<18, T, D, BrdRowWrap>,
+                row_filter::caller<19, T, D, BrdRowWrap>,
+                row_filter::caller<20, T, D, BrdRowWrap>,
+                row_filter::caller<21, T, D, BrdRowWrap>,
+                row_filter::caller<22, T, D, BrdRowWrap>,
+                row_filter::caller<23, T, D, BrdRowWrap>,
+                row_filter::caller<24, T, D, BrdRowWrap>,
+                row_filter::caller<25, T, D, BrdRowWrap>,
+                row_filter::caller<26, T, D, BrdRowWrap>,
+                row_filter::caller<27, T, D, BrdRowWrap>,
+                row_filter::caller<28, T, D, BrdRowWrap>,
+                row_filter::caller<29, T, D, BrdRowWrap>,
+                row_filter::caller<30, T, D, BrdRowWrap>,
+                row_filter::caller<31, T, D, BrdRowWrap>,
+                row_filter::caller<32, T, D, BrdRowWrap>
             }
         };
 
-        loadKernel(kernel, ksize, stream);
+        if (stream == 0)
+            cudaSafeCall( cudaMemcpyToSymbol(row_filter::c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice) );
+        else
+            cudaSafeCall( cudaMemcpyToSymbolAsync(row_filter::c_kernel, kernel, ksize * sizeof(float), 0, cudaMemcpyDeviceToDevice, stream) );
 
         callers[brd_type][ksize]((PtrStepSz<T>)src, (PtrStepSz<D>)dst, anchor, cc, stream);
     }
diff --git a/modules/gpu/src/cuda/split_merge.cu b/modules/gpu/src/cuda/split_merge.cu
index a62c76bbe..834b283f0 100644
--- a/modules/gpu/src/cuda/split_merge.cu
+++ b/modules/gpu/src/cuda/split_merge.cu
@@ -508,4 +508,4 @@ namespace cv { namespace gpu { namespace device
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/tvl1flow.cu b/modules/gpu/src/cuda/tvl1flow.cu
index dc07d2f2e..27694ad26 100644
--- a/modules/gpu/src/cuda/tvl1flow.cu
+++ b/modules/gpu/src/cuda/tvl1flow.cu
@@ -52,9 +52,9 @@ using namespace cv::gpu::device;
 ////////////////////////////////////////////////////////////
 // centeredGradient
 
-namespace
+namespace tvl1flow
 {
-    __global__ void centeredGradient(const PtrStepSzf src, PtrStepf dx, PtrStepf dy)
+    __global__ void centeredGradientKernel(const PtrStepSzf src, PtrStepf dx, PtrStepf dy)
     {
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -65,16 +65,13 @@ namespace
         dx(y, x) = 0.5f * (src(y, ::min(x + 1, src.cols - 1)) - src(y, ::max(x - 1, 0)));
         dy(y, x) = 0.5f * (src(::min(y + 1, src.rows - 1), x) - src(::max(y - 1, 0), x));
     }
-}
 
-namespace tvl1flow
-{
     void centeredGradient(PtrStepSzf src, PtrStepSzf dx, PtrStepSzf dy)
     {
         const dim3 block(32, 8);
         const dim3 grid(divUp(src.cols, block.x), divUp(src.rows, block.y));
 
-        ::centeredGradient<<<grid, block>>>(src, dx, dy);
+        centeredGradientKernel<<<grid, block>>>(src, dx, dy);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -84,7 +81,7 @@ namespace tvl1flow
 ////////////////////////////////////////////////////////////
 // warpBackward
 
-namespace
+namespace tvl1flow
 {
     static __device__ __forceinline__ float bicubicCoeff(float x_)
     {
@@ -107,7 +104,7 @@ namespace
     texture<float, cudaTextureType2D, cudaReadModeElementType> tex_I1x(false, cudaFilterModePoint, cudaAddressModeClamp);
     texture<float, cudaTextureType2D, cudaReadModeElementType> tex_I1y(false, cudaFilterModePoint, cudaAddressModeClamp);
 
-    __global__ void warpBackward(const PtrStepSzf I0, const PtrStepf u1, const PtrStepf u2, PtrStepf I1w, PtrStepf I1wx, PtrStepf I1wy, PtrStepf grad, PtrStepf rho)
+    __global__ void warpBackwardKernel(const PtrStepSzf I0, const PtrStepf u1, const PtrStepf u2, PtrStepf I1w, PtrStepf I1wx, PtrStepf I1wy, PtrStepf grad, PtrStepf rho)
     {
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -166,10 +163,7 @@ namespace
         const float I0Val = I0(y, x);
         rho(y, x) = I1wVal - I1wxVal * u1Val - I1wyVal * u2Val - I0Val;
     }
-}
 
-namespace tvl1flow
-{
     void warpBackward(PtrStepSzf I0, PtrStepSzf I1, PtrStepSzf I1x, PtrStepSzf I1y, PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf I1w, PtrStepSzf I1wx, PtrStepSzf I1wy, PtrStepSzf grad, PtrStepSzf rho)
     {
         const dim3 block(32, 8);
@@ -179,7 +173,7 @@ namespace tvl1flow
         bindTexture(&tex_I1x, I1x);
         bindTexture(&tex_I1y, I1y);
 
-        ::warpBackward<<<grid, block>>>(I0, u1, u2, I1w, I1wx, I1wy, grad, rho);
+        warpBackwardKernel<<<grid, block>>>(I0, u1, u2, I1w, I1wx, I1wy, grad, rho);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -189,7 +183,7 @@ namespace tvl1flow
 ////////////////////////////////////////////////////////////
 // estimateU
 
-namespace
+namespace tvl1flow
 {
     __device__ float divergence(const PtrStepf& v1, const PtrStepf& v2, int y, int x)
     {
@@ -213,7 +207,7 @@ namespace
         }
     }
 
-    __global__ void estimateU(const PtrStepSzf I1wx, const PtrStepf I1wy,
+    __global__ void estimateUKernel(const PtrStepSzf I1wx, const PtrStepf I1wy,
                               const PtrStepf grad, const PtrStepf rho_c,
                               const PtrStepf p11, const PtrStepf p12, const PtrStepf p21, const PtrStepf p22,
                               PtrStepf u1, PtrStepf u2, PtrStepf error,
@@ -275,10 +269,7 @@ namespace
         const float n2 = (u2OldVal - u2NewVal) * (u2OldVal - u2NewVal);
         error(y, x) = n1 + n2;
     }
-}
 
-namespace tvl1flow
-{
     void estimateU(PtrStepSzf I1wx, PtrStepSzf I1wy,
                    PtrStepSzf grad, PtrStepSzf rho_c,
                    PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22,
@@ -288,7 +279,7 @@ namespace tvl1flow
         const dim3 block(32, 8);
         const dim3 grid(divUp(I1wx.cols, block.x), divUp(I1wx.rows, block.y));
 
-        ::estimateU<<<grid, block>>>(I1wx, I1wy, grad, rho_c, p11, p12, p21, p22, u1, u2, error, l_t, theta);
+        estimateUKernel<<<grid, block>>>(I1wx, I1wy, grad, rho_c, p11, p12, p21, p22, u1, u2, error, l_t, theta);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
@@ -298,9 +289,9 @@ namespace tvl1flow
 ////////////////////////////////////////////////////////////
 // estimateDualVariables
 
-namespace
+namespace tvl1flow
 {
-    __global__ void estimateDualVariables(const PtrStepSzf u1, const PtrStepf u2, PtrStepf p11, PtrStepf p12, PtrStepf p21, PtrStepf p22, const float taut)
+    __global__ void estimateDualVariablesKernel(const PtrStepSzf u1, const PtrStepf u2, PtrStepf p11, PtrStepf p12, PtrStepf p21, PtrStepf p22, const float taut)
     {
         const int x = blockIdx.x * blockDim.x + threadIdx.x;
         const int y = blockIdx.y * blockDim.y + threadIdx.y;
@@ -325,16 +316,13 @@ namespace
         p21(y, x) = (p21(y, x) + taut * u2x) / ng2;
         p22(y, x) = (p22(y, x) + taut * u2y) / ng2;
     }
-}
 
-namespace tvl1flow
-{
     void estimateDualVariables(PtrStepSzf u1, PtrStepSzf u2, PtrStepSzf p11, PtrStepSzf p12, PtrStepSzf p21, PtrStepSzf p22, float taut)
     {
         const dim3 block(32, 8);
         const dim3 grid(divUp(u1.cols, block.x), divUp(u1.rows, block.y));
 
-        ::estimateDualVariables<<<grid, block>>>(u1, u2, p11, p12, p21, p22, taut);
+        estimateDualVariablesKernel<<<grid, block>>>(u1, u2, p11, p12, p21, p22, taut);
         cudaSafeCall( cudaGetLastError() );
 
         cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index edafd5758..d430eceae 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -551,7 +551,7 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
     src.locateROI(whole, offset);
 
     if (info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048
-        && offset.x % 16 == 0 && ((src.cols + 63) / 64) * 64 <= (src.step - offset.x))
+        && offset.x % 16 == 0 && ((src.cols + 63) / 64) * 64 <= (static_cast<int>(src.step) - offset.x))
     {
         ensureSizeIsEnough(((src.rows + 7) / 8) * 8, ((src.cols + 63) / 64) * 64, CV_32SC1, buffer);
 
diff --git a/modules/gpu/test/nvidia/TestHaarCascadeApplication.cpp b/modules/gpu/test/nvidia/TestHaarCascadeApplication.cpp
index 99913b885..dd410cd51 100644
--- a/modules/gpu/test/nvidia/TestHaarCascadeApplication.cpp
+++ b/modules/gpu/test/nvidia/TestHaarCascadeApplication.cpp
@@ -210,6 +210,18 @@ bool TestHaarCascadeApplication::process()
 #if defined(__GNUC__)
     //http://www.christian-seiler.de/projekte/fpmath/
 
+    #ifndef _FPU_EXTENDED
+    #define _FPU_EXTENDED 0
+    #endif
+
+    #ifndef _FPU_DOUBLE
+    #define _FPU_DOUBLE 0
+    #endif
+
+    #ifndef _FPU_SINGLE
+    #define _FPU_SINGLE 0
+    #endif
+
     fpu_control_t fpu_oldcw, fpu_cw;
     _FPU_GETCW(fpu_oldcw); // store old cw
      fpu_cw = (fpu_oldcw & ~_FPU_EXTENDED & ~_FPU_DOUBLE & ~_FPU_SINGLE) | _FPU_SINGLE;
@@ -302,4 +314,4 @@ bool TestHaarCascadeApplication::deinit()
     return true;
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/samples/gpu/driver_api_multi.cpp b/samples/gpu/driver_api_multi.cpp
index 560908ce6..2d743f0e9 100644
--- a/samples/gpu/driver_api_multi.cpp
+++ b/samples/gpu/driver_api_multi.cpp
@@ -54,14 +54,8 @@ inline void safeCall_(int code, const char* expr, const char* file, int line)
 // Each GPU is associated with its own context
 CUcontext contexts[2];
 
-int main(int argc, char **argv)
+int main()
 {
-    if (argc > 1)
-    {
-        cout << "CUDA driver API sample\n";
-        return -1;
-    }
-
     int num_devices = getCudaEnabledDeviceCount();
     if (num_devices < 2)
     {
diff --git a/samples/gpu/driver_api_stereo_multi.cpp b/samples/gpu/driver_api_stereo_multi.cpp
index 3c663a5e5..b8f99e810 100644
--- a/samples/gpu/driver_api_stereo_multi.cpp
+++ b/samples/gpu/driver_api_stereo_multi.cpp
@@ -76,7 +76,7 @@ GpuMat d_result[2];
 // CPU result
 Mat result;
 
-void printHelp()
+static void printHelp()
 {
     std::cout << "Usage: driver_api_stereo_multi_gpu --left <left_image> --right <right_image>\n";
 }
diff --git a/samples/gpu/softcascade.cpp b/samples/gpu/softcascade.cpp
index 3c08fdb1c..fe518504b 100644
--- a/samples/gpu/softcascade.cpp
+++ b/samples/gpu/softcascade.cpp
@@ -76,8 +76,7 @@ int main(int argc, char** argv)
 
         cv::gpu::GpuMat dframe(frame), roi(frame.rows, frame.cols, CV_8UC1), trois;
         roi.setTo(cv::Scalar::all(1));
-        cascade.genRoi(roi, trois);
-        cascade.detect(dframe, trois, objects);
+        cascade.detect(dframe, roi, objects);
 
         cv::Mat dt(objects);
         typedef cv::gpu::SCascade::Detection Detection;
@@ -103,4 +102,4 @@ int main(int argc, char** argv)
     }
 
     return 0;
-}
\ No newline at end of file
+}

From 8c057af862785ccb898a0916a30cc5bd00e8622e Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 13 Dec 2012 15:40:05 +0400
Subject: [PATCH 140/155] fixed windows build

---
 modules/gpu/include/opencv2/gpu/device/common.hpp | 3 +++
 modules/gpu/src/cuda/element_operations.cu        | 2 +-
 modules/gpu/src/cuda/icf-sc.cu                    | 8 ++++----
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/device/common.hpp b/modules/gpu/include/opencv2/gpu/device/common.hpp
index e44c8442f..931e4247e 100644
--- a/modules/gpu/include/opencv2/gpu/device/common.hpp
+++ b/modules/gpu/include/opencv2/gpu/device/common.hpp
@@ -100,6 +100,9 @@ namespace cv { namespace gpu
         typedef unsigned char uchar;
         typedef unsigned short ushort;
         typedef signed char schar;
+        #ifdef WIN32
+            typedef unsigned int uint;
+        #endif
 
         template<class T> inline void bindTexture(const textureReference* tex, const PtrStepSz<T>& img)
         {
diff --git a/modules/gpu/src/cuda/element_operations.cu b/modules/gpu/src/cuda/element_operations.cu
index 8faaca8bf..27fb61ff7 100644
--- a/modules/gpu/src/cuda/element_operations.cu
+++ b/modules/gpu/src/cuda/element_operations.cu
@@ -1409,7 +1409,7 @@ namespace arithm
     {
         S val;
 
-        explicit DivInv(double val_) : val(val_) {}
+        explicit DivInv(S val_) : val(val_) {}
 
         __device__ __forceinline__ D operator ()(T a) const
         {
diff --git a/modules/gpu/src/cuda/icf-sc.cu b/modules/gpu/src/cuda/icf-sc.cu
index 58d6883e8..aa695372e 100644
--- a/modules/gpu/src/cuda/icf-sc.cu
+++ b/modules/gpu/src/cuda/icf-sc.cu
@@ -138,10 +138,10 @@ namespace icf {
     template<bool isDefaultNum>
     __device__ __forceinline__ int fast_angle_bin(const float& dx, const float& dy)
     {
-        const float angle_quantum = M_PI / 6.f;
+        const float angle_quantum = CV_PI / 6.f;
         float angle = atan2(dx, dy) + (angle_quantum / 2.f);
 
-        if (angle < 0) angle += M_PI;
+        if (angle < 0) angle += CV_PI;
 
         const float angle_scaling = 1.f / angle_quantum;
         return static_cast<int>(angle * angle_scaling) % 6;
@@ -175,8 +175,8 @@ namespace icf {
         {
             int i = 3;
             float2 bin_vector_i;
-            bin_vector_i.x = ::cos(i * (M_PI / 6.f));
-            bin_vector_i.y = ::sin(i * (M_PI / 6.f));
+            bin_vector_i.x = ::cos(i * (CV_PI / 6.f));
+            bin_vector_i.y = ::sin(i * (CV_PI / 6.f));
 
             const float dot_product = fabs(dx * bin_vector_i.x + dy * bin_vector_i.y);
             if(dot_product > max_dot)

From caf91ac159821dc44e9f781d9609fe46fd53b24e Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 13 Dec 2012 17:18:25 +0400
Subject: [PATCH 141/155] new gpu::HoughLinesP implementation

---
 modules/gpu/include/opencv2/gpu/gpu.hpp |   2 +-
 modules/gpu/perf/perf_imgproc.cpp       |  14 +-
 modules/gpu/src/cuda/hough.cu           | 207 +++++++++++++++++-------
 modules/gpu/src/hough.cpp               |  39 +++--
 samples/gpu/houghlines.cpp              |  10 +-
 samples/gpu/softcascade.cpp             |   2 +-
 6 files changed, 190 insertions(+), 84 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 866c3de7d..298bf918a 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -850,7 +850,7 @@ CV_EXPORTS void HoughLinesDownload(const GpuMat& d_lines, OutputArray h_lines, O
 //! HoughLinesP
 
 //! finds line segments in the black-n-white image using probabalistic Hough transform
-CV_EXPORTS void HoughLinesP(const GpuMat& image, GpuMat& lines, CannyBuf& cannyBuf, int minLineLength, int maxLineGap, int maxLines = 4096);
+CV_EXPORTS void HoughLinesP(const GpuMat& image, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int minLineLength, int maxLineGap, int maxLines = 4096);
 
 //! HoughCircles
 
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index b8feab83a..ee0968442 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -1813,17 +1813,20 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
 
     cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
 
+    cv::Mat mask;
+    cv::Canny(image, mask, 50, 100);
+
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_mask(mask);
         cv::gpu::GpuMat d_lines;
-        cv::gpu::CannyBuf d_buf;
+        cv::gpu::HoughLinesBuf d_buf;
 
-        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+        cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
 
         TEST_CYCLE()
         {
-            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+            cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
         }
 
         cv::Mat h_lines(d_lines);
@@ -1834,9 +1837,6 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
     }
     else
     {
-        cv::Mat mask;
-        cv::Canny(image, mask, 50, 100);
-
         std::vector<cv::Vec4i> lines;
         cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
 
diff --git a/modules/gpu/src/cuda/hough.cu b/modules/gpu/src/cuda/hough.cu
index c4dfbcb66..695a47def 100644
--- a/modules/gpu/src/cuda/hough.cu
+++ b/modules/gpu/src/cuda/hough.cu
@@ -298,79 +298,168 @@ namespace cv { namespace gpu { namespace device
 
         texture<uchar, cudaTextureType2D, cudaReadModeElementType> tex_mask(false, cudaFilterModePoint, cudaAddressModeClamp);
 
-        __global__ void houghLinesProbabilistic(const PtrStepSzi Dx, const PtrStepi Dy,
+        __global__ void houghLinesProbabilistic(const PtrStepSzi accum,
                                                 int4* out, const int maxSize,
-                                                const int lineGap, const int lineLength)
+                                                const float rho, const float theta,
+                                                const int lineGap, const int lineLength,
+                                                const int rows, const int cols)
         {
-            const int SHIFT = 10;
+            const int r = blockIdx.x * blockDim.x + threadIdx.x;
+            const int n = blockIdx.y * blockDim.y + threadIdx.y;
 
-            const int x = blockIdx.x * blockDim.x + threadIdx.x;
-            const int y = blockIdx.y * blockDim.y + threadIdx.y;
-
-            if (x >= Dx.cols || y >= Dx.rows || tex2D(tex_mask, x, y) == 0)
+            if (r >= accum.cols - 2 || n >= accum.rows - 2)
                 return;
 
-            const int dx = Dx(y, x);
-            const int dy = Dy(y, x);
+            const int curVotes = accum(n + 1, r + 1);
 
-            if (dx == 0 && dy == 0)
-                return;
-
-            const int vx = dy;
-            const int vy = -dx;
-
-            const float mag = ::sqrtf(vx * vx + vy * vy);
-
-            const int x0 = x << SHIFT;
-            const int y0 = y << SHIFT;
-
-            int sx = __float2int_rn((vx << SHIFT) / mag);
-            int sy = __float2int_rn((vy << SHIFT) / mag);
-
-            int2 line_end[2] = {make_int2(x,y), make_int2(x,y)};
-
-            for (int k = 0; k < 2; ++k)
+            if (curVotes >= lineLength &&
+                curVotes > accum(n, r) &&
+                curVotes > accum(n, r + 1) &&
+                curVotes > accum(n, r + 2) &&
+                curVotes > accum(n + 1, r) &&
+                curVotes > accum(n + 1, r + 2) &&
+                curVotes > accum(n + 2, r) &&
+                curVotes > accum(n + 2, r + 1) &&
+                curVotes > accum(n + 2, r + 2))
             {
-                int gap = 0;
-                int x1 = x0 + sx;
-                int y1 = y0 + sy;
+                const float radius = (r - (accum.cols - 2 - 1) * 0.5f) * rho;
+                const float angle = n * theta;
 
-                for (;; x1 += sx, y1 += sy)
+                float cosa;
+                float sina;
+                sincosf(angle, &sina, &cosa);
+
+                float2 p0 = make_float2(cosa * radius, sina * radius);
+                float2 dir = make_float2(-sina, cosa);
+
+                float2 pb[4] = {make_float2(-1, -1), make_float2(-1, -1), make_float2(-1, -1), make_float2(-1, -1)};
+                float a;
+
+                if (dir.x != 0)
                 {
-                    const int x2 = x1 >> SHIFT;
-                    const int y2 = y1 >> SHIFT;
+                    a = -p0.x / dir.x;
+                    pb[0].x = 0;
+                    pb[0].y = p0.y + a * dir.y;
 
-                    if (x2 < 0 || x2 >= Dx.cols || y2 < 0 || y2 >= Dx.rows)
-                        break;
+                    a = (cols - 1 - p0.x) / dir.x;
+                    pb[1].x = cols - 1;
+                    pb[1].y = p0.y + a * dir.y;
+                }
+                if (dir.y != 0)
+                {
+                    a = -p0.y / dir.y;
+                    pb[2].x = p0.x + a * dir.x;
+                    pb[2].y = 0;
 
-                    if (tex2D(tex_mask, x2, y2))
-                    {
-                        gap = 0;
-                        line_end[k].x = x2;
-                        line_end[k].y = y2;
-                    }
-                    else if(++gap > lineGap)
-                        break;
+                    a = (rows - 1 - p0.y) / dir.y;
+                    pb[3].x = p0.x + a * dir.x;
+                    pb[3].y = rows - 1;
                 }
 
-                sx = -sx;
-                sy = -sy;
-            }
+                if (pb[0].x == 0 && (pb[0].y >= 0 && pb[0].y < rows))
+                {
+                    p0 = pb[0];
+                    if (dir.x < 0)
+                        dir = -dir;
+                }
+                else if (pb[1].x == cols - 1 && (pb[0].y >= 0 && pb[0].y < rows))
+                {
+                    p0 = pb[1];
+                    if (dir.x > 0)
+                        dir = -dir;
+                }
+                else if (pb[2].y == 0 && (pb[2].x >= 0 && pb[2].x < cols))
+                {
+                    p0 = pb[2];
+                    if (dir.y < 0)
+                        dir = -dir;
+                }
+                else if (pb[3].y == rows - 1 && (pb[3].x >= 0 && pb[3].x < cols))
+                {
+                    p0 = pb[3];
+                    if (dir.y > 0)
+                        dir = -dir;
+                }
 
-            const bool good_line = ::abs(line_end[1].x - line_end[0].x) >= lineLength ||
-                                   ::abs(line_end[1].y - line_end[0].y) >= lineLength;
+                float2 d;
+                if (::fabsf(dir.x) > ::fabsf(dir.y))
+                {
+                    d.x = dir.x > 0 ? 1 : -1;
+                    d.y = dir.y / ::fabsf(dir.x);
+                }
+                else
+                {
+                    d.x = dir.x / ::fabsf(dir.y);
+                    d.y = dir.y > 0 ? 1 : -1;
+                }
 
-            if (good_line)
-            {
-                const int ind = ::atomicAdd(&g_counter, 1);
-                if (ind < maxSize)
-                    out[ind] = make_int4(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+                float2 line_end[2];
+                int gap;
+                bool inLine = false;
+
+                float2 p1 = p0;
+                if (p1.x < 0 || p1.x >= cols || p1.y < 0 || p1.y >= rows)
+                    return;
+
+                for (;;)
+                {
+                    if (tex2D(tex_mask, p1.x, p1.y))
+                    {
+                        gap = 0;
+
+                        if (!inLine)
+                        {
+                            line_end[0] = p1;
+                            line_end[1] = p1;
+                            inLine = true;
+                        }
+                        else
+                        {
+                            line_end[1] = p1;
+                        }
+                    }
+                    else if (inLine)
+                    {
+                        if (++gap > lineGap)
+                        {
+                            bool good_line = ::abs(line_end[1].x - line_end[0].x) >= lineLength ||
+                                             ::abs(line_end[1].y - line_end[0].y) >= lineLength;
+
+                            if (good_line)
+                            {
+                                const int ind = ::atomicAdd(&g_counter, 1);
+                                if (ind < maxSize)
+                                    out[ind] = make_int4(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+                            }
+
+                            gap = 0;
+                            inLine = false;
+                        }
+                    }
+
+                    p1 = p1 + d;
+                    if (p1.x < 0 || p1.x >= cols || p1.y < 0 || p1.y >= rows)
+                    {
+                        if (inLine)
+                        {
+                            bool good_line = ::abs(line_end[1].x - line_end[0].x) >= lineLength ||
+                                             ::abs(line_end[1].y - line_end[0].y) >= lineLength;
+
+                            if (good_line)
+                            {
+                                const int ind = ::atomicAdd(&g_counter, 1);
+                                if (ind < maxSize)
+                                    out[ind] = make_int4(line_end[0].x, line_end[0].y, line_end[1].x, line_end[1].y);
+                            }
+
+                        }
+                        break;
+                    }
+                }
             }
         }
 
-        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi Dx, PtrStepSzi Dy,
-                                        int4* out, int maxSize,
-                                        int lineGap, int lineLength)
+        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength)
         {
             void* counterPtr;
             cudaSafeCall( cudaGetSymbolAddress(&counterPtr, g_counter) );
@@ -378,11 +467,15 @@ namespace cv { namespace gpu { namespace device
             cudaSafeCall( cudaMemset(counterPtr, 0, sizeof(int)) );
 
             const dim3 block(32, 8);
-            const dim3 grid(divUp(mask.cols, block.x), divUp(mask.rows, block.y));
+            const dim3 grid(divUp(accum.cols - 2, block.x), divUp(accum.rows - 2, block.y));
 
             bindTexture(&tex_mask, mask);
 
-            houghLinesProbabilistic<<<grid, block>>>(Dx, Dy, out, maxSize, lineGap, lineLength);
+            houghLinesProbabilistic<<<grid, block>>>(accum,
+                                                     out, maxSize,
+                                                     rho, theta,
+                                                     lineGap, lineLength,
+                                                     mask.rows, mask.cols);
             cudaSafeCall( cudaGetLastError() );
 
             cudaSafeCall( cudaDeviceSynchronize() );
diff --git a/modules/gpu/src/hough.cpp b/modules/gpu/src/hough.cpp
index daeb62536..b1751076c 100644
--- a/modules/gpu/src/hough.cpp
+++ b/modules/gpu/src/hough.cpp
@@ -52,7 +52,7 @@ void cv::gpu::HoughLines(const GpuMat&, GpuMat&, float, float, int, bool, int) {
 void cv::gpu::HoughLines(const GpuMat&, GpuMat&, HoughLinesBuf&, float, float, int, bool, int) { throw_nogpu(); }
 void cv::gpu::HoughLinesDownload(const GpuMat&, OutputArray, OutputArray) { throw_nogpu(); }
 
-void cv::gpu::HoughLinesP(const GpuMat&, GpuMat&, CannyBuf&, int, int, int) { throw_nogpu(); }
+void cv::gpu::HoughLinesP(const GpuMat&, GpuMat&, HoughLinesBuf&, float, float, int, int, int) { throw_nogpu(); }
 
 void cv::gpu::HoughCircles(const GpuMat&, GpuMat&, int, float, float, int, int, int, int, int) { throw_nogpu(); }
 void cv::gpu::HoughCircles(const GpuMat&, GpuMat&, HoughCirclesBuf&, int, float, float, int, int, int, int, int) { throw_nogpu(); }
@@ -164,28 +164,41 @@ namespace cv { namespace gpu { namespace device
 {
     namespace hough
     {
-        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi Dx, PtrStepSzi Dy,
-                                        int4* out, int maxSize,
-                                        int lineGap, int lineLength);
+        int houghLinesProbabilistic_gpu(PtrStepSzb mask, PtrStepSzi accum, int4* out, int maxSize, float rho, float theta, int lineGap, int lineLength);
     }
 }}}
 
-void cv::gpu::HoughLinesP(const GpuMat& image, GpuMat& lines, CannyBuf& cannyBuf, int minLineLength, int maxLineGap, int maxLines)
+void cv::gpu::HoughLinesP(const GpuMat& src, GpuMat& lines, HoughLinesBuf& buf, float rho, float theta, int minLineLength, int maxLineGap, int maxLines)
 {
     using namespace cv::gpu::device::hough;
 
-    CV_Assert( image.type() == CV_8UC1 );
-    CV_Assert( image.cols < std::numeric_limits<unsigned short>::max() );
-    CV_Assert( image.rows < std::numeric_limits<unsigned short>::max() );
+    CV_Assert( src.type() == CV_8UC1 );
+    CV_Assert( src.cols < std::numeric_limits<unsigned short>::max() );
+    CV_Assert( src.rows < std::numeric_limits<unsigned short>::max() );
 
-    GpuMat mask;
-    Canny(image, cannyBuf, mask, 50, 100);
+    ensureSizeIsEnough(1, src.size().area(), CV_32SC1, buf.list);
+    unsigned int* srcPoints = buf.list.ptr<unsigned int>();
+
+    const int pointsCount = buildPointList_gpu(src, srcPoints);
+    if (pointsCount == 0)
+    {
+        lines.release();
+        return;
+    }
+
+    const int numangle = cvRound(CV_PI / theta);
+    const int numrho = cvRound(((src.cols + src.rows) * 2 + 1) / rho);
+    CV_Assert( numangle > 0 && numrho > 0 );
+
+    ensureSizeIsEnough(numangle + 2, numrho + 2, CV_32SC1, buf.accum);
+    buf.accum.setTo(Scalar::all(0));
+
+    DeviceInfo devInfo;
+    linesAccum_gpu(srcPoints, pointsCount, buf.accum, rho, theta, devInfo.sharedMemPerBlock(), devInfo.supports(FEATURE_SET_COMPUTE_20));
 
     ensureSizeIsEnough(1, maxLines, CV_32SC4, lines);
 
-    int linesCount = houghLinesProbabilistic_gpu(mask, cannyBuf.dx, cannyBuf.dy,
-                                                 lines.ptr<int4>(), maxLines,
-                                                 maxLineGap, minLineLength);
+    int linesCount = houghLinesProbabilistic_gpu(src, buf.accum, lines.ptr<int4>(), maxLines, rho, theta, maxLineGap, minLineLength);
 
     if (linesCount > 0)
         lines.cols = linesCount;
diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp
index e9bb96915..0f1932672 100644
--- a/samples/gpu/houghlines.cpp
+++ b/samples/gpu/houghlines.cpp
@@ -30,14 +30,14 @@ int main(int argc, const char* argv[])
     }
 
     Mat mask;
-    Canny(src, mask, 50, 200, 3);
+    Canny(src, mask, 100, 200, 3);
 
     Mat dst_cpu;
     cvtColor(mask, dst_cpu, CV_GRAY2BGR);
     Mat dst_gpu = dst_cpu.clone();
 
     vector<Vec4i> lines_cpu;
-    HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 50, 5);
+    HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 60, 5);
     cout << lines_cpu.size() << endl;
 
     for (size_t i = 0; i < lines_cpu.size(); ++i)
@@ -46,10 +46,10 @@ int main(int argc, const char* argv[])
         line(dst_cpu, Point(l[0], l[1]), Point(l[2], l[3]), Scalar(0, 0, 255), 3, CV_AA);
     }
 
-    GpuMat d_src(src);
+    GpuMat d_src(mask);
     GpuMat d_lines;
-    CannyBuf d_buf;
-    gpu::HoughLinesP(d_src, d_lines, d_buf, 50, 5);
+    HoughLinesBuf d_buf;
+    gpu::HoughLinesP(d_src, d_lines, d_buf, 1, CV_PI / 180, 50, 5);
     vector<Vec4i> lines_gpu;
     if (!d_lines.empty())
     {
diff --git a/samples/gpu/softcascade.cpp b/samples/gpu/softcascade.cpp
index fe518504b..66f82d50b 100644
--- a/samples/gpu/softcascade.cpp
+++ b/samples/gpu/softcascade.cpp
@@ -74,7 +74,7 @@ int main(int argc, char** argv)
             return 0;
         }
 
-        cv::gpu::GpuMat dframe(frame), roi(frame.rows, frame.cols, CV_8UC1), trois;
+        cv::gpu::GpuMat dframe(frame), roi(frame.rows, frame.cols, CV_8UC1);
         roi.setTo(cv::Scalar::all(1));
         cascade.detect(dframe, roi, objects);
 

From da017fbeb9b3b27930dfce7cbbf943dd14c4d0ec Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 17 Dec 2012 10:39:19 +0400
Subject: [PATCH 142/155] fast optical flow bm implementation

---
 modules/gpu/app/nv_perf_test/main.cpp         |  59 ++++-
 modules/gpu/include/opencv2/gpu/gpu.hpp       |  11 +
 modules/gpu/perf/perf_video.cpp               |  49 ++++
 modules/gpu/src/cuda/optflowbm.cu             | 247 ++++++++++++++++++
 modules/gpu/src/optflowbm.cpp                 |  38 +++
 modules/gpu/test/test_video.cpp               | 115 ++++++++
 ...tvl1_optical_flow.cpp => optical_flow.cpp} | 101 ++++++-
 7 files changed, 607 insertions(+), 13 deletions(-)
 rename samples/gpu/{tvl1_optical_flow.cpp => optical_flow.cpp} (61%)

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
index 3d457e492..928b30a19 100644
--- a/modules/gpu/app/nv_perf_test/main.cpp
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -94,13 +94,13 @@ PERF_TEST_P(Image, HoughLinesP,
     {
         cv::gpu::GpuMat d_image(image);
         cv::gpu::GpuMat d_lines;
-        cv::gpu::CannyBuf d_buf;
+        cv::gpu::HoughLinesBuf d_buf;
 
-        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
 
         TEST_CYCLE()
         {
-            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, minLineLenght, maxLineGap);
+            cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
         }
     }
     else
@@ -434,3 +434,56 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
 
     SANITY_CHECK(0);
 }
+
+PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
+            testing::Combine(
+                testing::Values(string_pair("im1_1280x800.jpg", "im2_1280x800.jpg")),
+                testing::Values(cv::Size(16, 16)),
+                testing::Values(cv::Size(1, 1)),
+                testing::Values(cv::Size(16, 16))
+                ))
+{
+    declare.time(1000);
+
+    const string_pair fileNames = std::tr1::get<0>(GetParam());
+    const cv::Size block_size = std::tr1::get<1>(GetParam());
+    const cv::Size shift_size = std::tr1::get<2>(GetParam());
+    const cv::Size max_range = std::tr1::get<3>(GetParam());
+
+    cv::Mat src1 = cv::imread(fileNames.first, cv::IMREAD_GRAYSCALE);
+    if (src1.empty())
+        FAIL() << "Unable to load source image [" << fileNames.first << "]";
+
+    cv::Mat src2 = cv::imread(fileNames.second, cv::IMREAD_GRAYSCALE);
+    if (src2.empty())
+        FAIL() << "Unable to load source image [" << fileNames.second << "]";
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely;
+
+        cv::gpu::FastOpticalFlowBM fastBM;
+
+        fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+
+        TEST_CYCLE_N(10)
+        {
+            fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+        }
+    }
+    else
+    {
+        cv::Mat velx, vely;
+
+        calcOpticalFlowBM(src1, src2, block_size, shift_size, max_range, false, velx, vely);
+
+        TEST_CYCLE_N(10)
+        {
+            calcOpticalFlowBM(src1, src2, block_size, shift_size, max_range, false, velx, vely);
+        }
+    }
+
+    SANITY_CHECK(0);
+}
diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 298bf918a..895afb274 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -2129,6 +2129,17 @@ CV_EXPORTS void calcOpticalFlowBM(const GpuMat& prev, const GpuMat& curr,
                                   GpuMat& velx, GpuMat& vely, GpuMat& buf,
                                   Stream& stream = Stream::Null());
 
+class CV_EXPORTS FastOpticalFlowBM
+{
+public:
+    void operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy, int search_window = 21, int block_window = 7, Stream& s = Stream::Null());
+
+private:
+    GpuMat buffer;
+    GpuMat extended_I0;
+    GpuMat extended_I1;
+};
+
 
 //! Interpolate frames (images) using provided optical flow (displacement field).
 //! frame0   - frame 0 (32-bit floating point images, single channel)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index edbe2aacd..5afe0d15f 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -512,6 +512,55 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
     }
 }
 
+PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
+    Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
+{
+    declare.time(400);
+
+    cv::Mat frame0 = readImage(GetParam().first, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage(GetParam().second, cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
+
+    if (PERF_RUN_GPU())
+    {
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely;
+
+        cv::gpu::FastOpticalFlowBM fastBM;
+
+        fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+
+        TEST_CYCLE()
+        {
+            fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+        }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
+    }
+    else
+    {
+        cv::Mat velx, vely;
+
+        calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+
+        TEST_CYCLE()
+        {
+            calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+        }
+
+        CPU_SANITY_CHECK(velx);
+        CPU_SANITY_CHECK(vely);
+    }
+}
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 
diff --git a/modules/gpu/src/cuda/optflowbm.cu b/modules/gpu/src/cuda/optflowbm.cu
index 7e4acd900..f9090abdc 100644
--- a/modules/gpu/src/cuda/optflowbm.cu
+++ b/modules/gpu/src/cuda/optflowbm.cu
@@ -44,6 +44,8 @@
 
 #include "opencv2/gpu/device/common.hpp"
 #include "opencv2/gpu/device/limits.hpp"
+#include "opencv2/gpu/device/functional.hpp"
+#include "opencv2/gpu/device/reduce.hpp"
 
 using namespace cv::gpu;
 using namespace cv::gpu::device;
@@ -164,4 +166,249 @@ namespace optflowbm
     }
 }
 
+/////////////////////////////////////////////////////////
+// Fast approximate version
+
+namespace optflowbm_fast
+{
+    enum
+    {
+        CTA_SIZE = 128,
+
+        TILE_COLS = 128,
+        TILE_ROWS = 32,
+
+        STRIDE = CTA_SIZE
+    };
+
+    template <typename T> __device__ __forceinline__ int calcDist(T a, T b)
+    {
+        return ::abs(a - b);
+    }
+
+    template <class T> struct FastOptFlowBM
+    {
+
+        int search_radius;
+        int block_radius;
+
+        int search_window;
+        int block_window;
+
+        PtrStepSz<T> I0;
+        PtrStep<T> I1;
+
+        mutable PtrStepi buffer;
+
+        FastOptFlowBM(int search_window_, int block_window_,
+                      PtrStepSz<T> I0_, PtrStepSz<T> I1_,
+                      PtrStepi buffer_) :
+            search_radius(search_window_ / 2), block_radius(block_window_ / 2),
+            search_window(search_window_), block_window(block_window_),
+            I0(I0_), I1(I1_),
+            buffer(buffer_)
+        {
+        }
+
+        __device__ void initSums_BruteForce(int i, int j, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+        {
+            for (int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+            {
+                dist_sums[index] = 0;
+
+                for (int tx = 0; tx < block_window; ++tx)
+                    col_sums(tx, index) = 0;
+
+                int y = index / search_window;
+                int x = index - y * search_window;
+
+                int ay = i;
+                int ax = j;
+
+                int by = i + y - search_radius;
+                int bx = j + x - search_radius;
+
+                for (int tx = -block_radius; tx <= block_radius; ++tx)
+                {
+                    int col_sum = 0;
+                    for (int ty = -block_radius; ty <= block_radius; ++ty)
+                    {
+                        int dist = calcDist(I0(ay + ty, ax + tx), I1(by + ty, bx + tx));
+
+                        dist_sums[index] += dist;
+                        col_sum += dist;
+                    }
+
+                    col_sums(tx + block_radius, index) = col_sum;
+                }
+
+                up_col_sums(j, index) = col_sums(block_window - 1, index);
+            }
+        }
+
+        __device__ void shiftRight_FirstRow(int i, int j, int first, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+        {
+            for (int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+            {
+                int y = index / search_window;
+                int x = index - y * search_window;
+
+                int ay = i;
+                int ax = j + block_radius;
+
+                int by = i + y - search_radius;
+                int bx = j + x - search_radius + block_radius;
+
+                int col_sum = 0;
+
+                for (int ty = -block_radius; ty <= block_radius; ++ty)
+                    col_sum += calcDist(I0(ay + ty, ax), I1(by + ty, bx));
+
+                dist_sums[index] += col_sum - col_sums(first, index);
+
+                col_sums(first, index) = col_sum;
+                up_col_sums(j, index) = col_sum;
+            }
+        }
+
+        __device__ void shiftRight_UpSums(int i, int j, int first, int* dist_sums, PtrStepi& col_sums, PtrStepi& up_col_sums) const
+        {
+            int ay = i;
+            int ax = j + block_radius;
+
+            T a_up   = I0(ay - block_radius - 1, ax);
+            T a_down = I0(ay + block_radius, ax);
+
+            for(int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+            {
+                int y = index / search_window;
+                int x = index - y * search_window;
+
+                int by = i + y - search_radius;
+                int bx = j + x - search_radius + block_radius;
+
+                T b_up   = I1(by - block_radius - 1, bx);
+                T b_down = I1(by + block_radius, bx);
+
+                int col_sum = up_col_sums(j, index) + calcDist(a_down, b_down) - calcDist(a_up, b_up);
+
+                dist_sums[index] += col_sum  - col_sums(first, index);
+                col_sums(first, index) = col_sum;
+                up_col_sums(j, index) = col_sum;
+            }
+        }
+
+        __device__ void convolve_window(int i, int j, const int* dist_sums, float& velx, float& vely) const
+        {
+            int bestDist = numeric_limits<int>::max();
+            int bestInd = -1;
+
+            for (int index = threadIdx.x; index < search_window * search_window; index += STRIDE)
+            {
+                int curDist = dist_sums[index];
+                if (curDist < bestDist)
+                {
+                    bestDist = curDist;
+                    bestInd = index;
+                }
+            }
+
+            __shared__ int cta_dist_buffer[CTA_SIZE];
+            __shared__ int cta_ind_buffer[CTA_SIZE];
+
+            reduceKeyVal<CTA_SIZE>(cta_dist_buffer, bestDist, cta_ind_buffer, bestInd, threadIdx.x, less<int>());
+
+            if (threadIdx.x == 0)
+            {
+                int y = bestInd / search_window;
+                int x = bestInd - y * search_window;
+
+                velx = x - search_radius;
+                vely = y - search_radius;
+            }
+        }
+
+        __device__ void operator()(PtrStepf velx, PtrStepf vely) const
+        {
+            int tbx = blockIdx.x * TILE_COLS;
+            int tby = blockIdx.y * TILE_ROWS;
+
+            int tex = ::min(tbx + TILE_COLS, I0.cols);
+            int tey = ::min(tby + TILE_ROWS, I0.rows);
+
+            PtrStepi col_sums;
+            col_sums.data = buffer.ptr(I0.cols + blockIdx.x * block_window) + blockIdx.y * search_window * search_window;
+            col_sums.step = buffer.step;
+
+            PtrStepi up_col_sums;
+            up_col_sums.data = buffer.data + blockIdx.y * search_window * search_window;
+            up_col_sums.step = buffer.step;
+
+            extern __shared__ int dist_sums[]; //search_window * search_window
+
+            int first = 0;
+
+            for (int i = tby; i < tey; ++i)
+            {
+                for (int j = tbx; j < tex; ++j)
+                {
+                    __syncthreads();
+
+                    if (j == tbx)
+                    {
+                        initSums_BruteForce(i, j, dist_sums, col_sums, up_col_sums);
+                        first = 0;
+                    }
+                    else
+                    {
+                        if (i == tby)
+                          shiftRight_FirstRow(i, j, first, dist_sums, col_sums, up_col_sums);
+                        else
+                          shiftRight_UpSums(i, j, first, dist_sums, col_sums, up_col_sums);
+
+                        first = (first + 1) % block_window;
+                    }
+
+                    __syncthreads();
+
+                    convolve_window(i, j, dist_sums, velx(i, j), vely(i, j));
+                }
+            }
+        }
+
+    };
+
+    template<typename T> __global__ void optflowbm_fast_kernel(const FastOptFlowBM<T> fbm, PtrStepf velx, PtrStepf vely)
+    {
+        fbm(velx, vely);
+    }
+
+    void get_buffer_size(int src_cols, int src_rows, int search_window, int block_window, int& buffer_cols, int& buffer_rows)
+    {
+        dim3 grid(divUp(src_cols, TILE_COLS), divUp(src_rows, TILE_ROWS));
+
+        buffer_cols = search_window * search_window * grid.y;
+        buffer_rows = src_cols + block_window * grid.x;
+    }
+
+    template <typename T>
+    void calc(PtrStepSzb I0, PtrStepSzb I1, PtrStepSzf velx, PtrStepSzf vely, PtrStepi buffer, int search_window, int block_window, cudaStream_t stream)
+    {
+        FastOptFlowBM<T> fbm(search_window, block_window, I0, I1, buffer);
+
+        dim3 block(CTA_SIZE, 1);
+        dim3 grid(divUp(I0.cols, TILE_COLS), divUp(I0.rows, TILE_ROWS));
+
+        size_t smem = search_window * search_window * sizeof(int);
+
+        optflowbm_fast_kernel<<<grid, block, smem, stream>>>(fbm, velx, vely);
+        cudaSafeCall ( cudaGetLastError () );
+
+        if (stream == 0)
+            cudaSafeCall( cudaDeviceSynchronize() );
+    }
+
+    template void calc<uchar>(PtrStepSzb I0, PtrStepSzb I1, PtrStepSzf velx, PtrStepSzf vely, PtrStepi buffer, int search_window, int block_window, cudaStream_t stream);
+}
+
 #endif // !defined CUDA_DISABLER
diff --git a/modules/gpu/src/optflowbm.cpp b/modules/gpu/src/optflowbm.cpp
index ec2f0f9f9..a4321c89c 100644
--- a/modules/gpu/src/optflowbm.cpp
+++ b/modules/gpu/src/optflowbm.cpp
@@ -50,6 +50,8 @@ using namespace cv::gpu;
 
 void cv::gpu::calcOpticalFlowBM(const GpuMat&, const GpuMat&, Size, Size, Size, bool, GpuMat&, GpuMat&, GpuMat&, Stream&) { throw_nogpu(); }
 
+void cv::gpu::FastOpticalFlowBM::operator ()(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, int, int, Stream&) { throw_nogpu(); }
+
 #else // HAVE_CUDA
 
 namespace optflowbm
@@ -202,4 +204,40 @@ void cv::gpu::calcOpticalFlowBM(const GpuMat& prev, const GpuMat& curr, Size blo
                     maxX, maxY, acceptLevel, escapeLevel, buf.ptr<short2>(), ssCount, stream);
 }
 
+namespace optflowbm_fast
+{
+    void get_buffer_size(int src_cols, int src_rows, int search_window, int block_window, int& buffer_cols, int& buffer_rows);
+
+    template <typename T>
+    void calc(PtrStepSzb I0, PtrStepSzb I1, PtrStepSzf velx, PtrStepSzf vely, PtrStepi buffer, int search_window, int block_window, cudaStream_t stream);
+}
+
+void cv::gpu::FastOpticalFlowBM::operator ()(const GpuMat& I0, const GpuMat& I1, GpuMat& flowx, GpuMat& flowy, int search_window, int block_window, Stream& stream)
+{
+    CV_Assert( I0.type() == CV_8UC1 );
+    CV_Assert( I1.size() == I0.size() && I1.type() == I0.type() );
+
+    int border_size = search_window / 2 + block_window / 2;
+    Size esize = I0.size() + Size(border_size, border_size) * 2;
+
+    ensureSizeIsEnough(esize, I0.type(), extended_I0);
+    ensureSizeIsEnough(esize, I0.type(), extended_I1);
+
+    copyMakeBorder(I0, extended_I0, border_size, border_size, border_size, border_size, cv::BORDER_DEFAULT, Scalar(), stream);
+    copyMakeBorder(I1, extended_I1, border_size, border_size, border_size, border_size, cv::BORDER_DEFAULT, Scalar(), stream);
+
+    GpuMat I0_hdr = extended_I0(Rect(Point2i(border_size, border_size), I0.size()));
+    GpuMat I1_hdr = extended_I1(Rect(Point2i(border_size, border_size), I0.size()));
+
+    int bcols, brows;
+    optflowbm_fast::get_buffer_size(I0.cols, I0.rows, search_window, block_window, bcols, brows);
+
+    ensureSizeIsEnough(brows, bcols, CV_32SC1, buffer);
+
+    flowx.create(I0.size(), CV_32FC1);
+    flowy.create(I0.size(), CV_32FC1);
+
+    optflowbm_fast::calc<uchar>(I0_hdr, I1_hdr, flowx, flowy, buffer, search_window, block_window, StreamAccessor::getStream(stream));
+}
+
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index a4b98bb3d..97e792c7f 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -513,6 +513,121 @@ TEST_P(OpticalFlowBM, Accuracy)
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
 
+//////////////////////////////////////////////////////
+// FastOpticalFlowBM
+
+static void FastOpticalFlowBM_gold(const cv::Mat_<uchar>& I0, const cv::Mat_<uchar>& I1, cv::Mat_<float>& velx, cv::Mat_<float>& vely, int search_window, int block_window)
+{
+    velx.create(I0.size());
+    vely.create(I0.size());
+
+    int search_radius = search_window / 2;
+    int block_radius = block_window / 2;
+
+    for (int y = 0; y < I0.rows; ++y)
+    {
+        for (int x = 0; x < I0.cols; ++x)
+        {
+            int bestDist = std::numeric_limits<int>::max();
+            int bestDx = 0;
+            int bestDy = 0;
+
+            for (int dy = -search_radius; dy <= search_radius; ++dy)
+            {
+                for (int dx = -search_radius; dx <= search_radius; ++dx)
+                {
+                    int dist = 0;
+
+                    for (int by = -block_radius; by <= block_radius; ++by)
+                    {
+                        for (int bx = -block_radius; bx <= block_radius; ++bx)
+                        {
+                            int I0_val = I0(cv::borderInterpolate(y + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + bx, I0.cols, cv::BORDER_DEFAULT));
+                            int I1_val = I1(cv::borderInterpolate(y + dy + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + dx + bx, I0.cols, cv::BORDER_DEFAULT));
+
+                            dist += std::abs(I0_val - I1_val);
+                        }
+                    }
+
+                    if (dist < bestDist)
+                    {
+                        bestDist = dist;
+                        bestDx = dx;
+                        bestDy = dy;
+                    }
+                }
+            }
+
+            velx(y, x) = bestDx;
+            vely(y, x) = bestDy;
+        }
+    }
+}
+
+static double calc_rmse(const cv::Mat_<float>& flow1, const cv::Mat_<float>& flow2)
+{
+    double sum = 0.0;
+
+    for (int y = 0; y < flow1.rows; ++y)
+    {
+        for (int x = 0; x < flow1.cols; ++x)
+        {
+            double diff = flow1(y, x) - flow2(y, x);
+            sum += diff * diff;
+        }
+    }
+
+    return std::sqrt(sum / flow1.size().area());
+}
+
+struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+};
+
+TEST_P(FastOpticalFlowBM, Accuracy)
+{
+    const double MAX_RMSE = 0.6;
+
+    int search_window = 15;
+    int block_window = 5;
+
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size smallSize(320, 240);
+    cv::Mat frame0_small;
+    cv::Mat frame1_small;
+
+    cv::resize(frame0, frame0_small, smallSize);
+    cv::resize(frame1, frame1_small, smallSize);
+
+    cv::gpu::GpuMat d_flowx;
+    cv::gpu::GpuMat d_flowy;
+    cv::gpu::FastOpticalFlowBM fastBM;
+
+    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+
+    cv::Mat_<float> flowx;
+    cv::Mat_<float> flowy;
+    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+
+    double err;
+
+    err = calc_rmse(flowx, cv::Mat(d_flowx));
+    EXPECT_LE(err, MAX_RMSE);
+
+    err = calc_rmse(flowy, cv::Mat(d_flowy));
+    EXPECT_LE(err, MAX_RMSE);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
+
 //////////////////////////////////////////////////////
 // FGDStatModel
 
diff --git a/samples/gpu/tvl1_optical_flow.cpp b/samples/gpu/optical_flow.cpp
similarity index 61%
rename from samples/gpu/tvl1_optical_flow.cpp
rename to samples/gpu/optical_flow.cpp
index c13afc1c7..8afff89ea 100644
--- a/samples/gpu/tvl1_optical_flow.cpp
+++ b/samples/gpu/optical_flow.cpp
@@ -121,6 +121,17 @@ static void drawOpticalFlow(const Mat_<float>& flowx, const Mat_<float>& flowy,
     }
 }
 
+static void showFlow(const char* name, const GpuMat& d_flowx, const GpuMat& d_flowy)
+{
+    Mat flowx(d_flowx);
+    Mat flowy(d_flowy);
+
+    Mat out;
+    drawOpticalFlow(flowx, flowy, out, 10);
+
+    imshow(name, out);
+}
+
 int main(int argc, const char* argv[])
 {
     if (argc < 3)
@@ -152,20 +163,90 @@ int main(int argc, const char* argv[])
     GpuMat d_frame0(frame0);
     GpuMat d_frame1(frame1);
 
-    GpuMat d_flowx, d_flowy;
+    GpuMat d_flowx(frame0.size(), CV_32FC1);
+    GpuMat d_flowy(frame0.size(), CV_32FC1);
+
+    BroxOpticalFlow brox(0.197, 50.0, 0.8, 10, 77, 10);
+    PyrLKOpticalFlow lk; lk.winSize = Size(7, 7);
+    FarnebackOpticalFlow farn;
     OpticalFlowDual_TVL1_GPU tvl1;
+    FastOpticalFlowBM fastBM;
 
-    const double start = getTickCount();
-    tvl1(d_frame0, d_frame1, d_flowx, d_flowy);
-    const double timeSec = (getTickCount() - start) / getTickFrequency();
-    cout << "Time : " << timeSec << " sec" << endl;
+    {
+        GpuMat d_frame0f;
+        GpuMat d_frame1f;
 
-    Mat flowx(d_flowx);
-    Mat flowy(d_flowy);
-    Mat out;
-    drawOpticalFlow(flowx, flowy, out);
+        d_frame0.convertTo(d_frame0f, CV_32F, 1.0 / 255.0);
+        d_frame1.convertTo(d_frame1f, CV_32F, 1.0 / 255.0);
 
-    imshow("Flow", out);
+        const double start = getTickCount();
+
+        brox(d_frame0f, d_frame1f, d_flowx, d_flowy);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "Brox : " << timeSec << " sec" << endl;
+
+        showFlow("Brox", d_flowx, d_flowy);
+    }
+
+    {
+        const double start = getTickCount();
+
+        lk.dense(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "LK : " << timeSec << " sec" << endl;
+
+        showFlow("LK", d_flowx, d_flowy);
+    }
+
+    {
+        const double start = getTickCount();
+
+        farn(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "Farn : " << timeSec << " sec" << endl;
+
+        showFlow("Farn", d_flowx, d_flowy);
+    }
+
+    {
+        const double start = getTickCount();
+
+        tvl1(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "TVL1 : " << timeSec << " sec" << endl;
+
+        showFlow("TVL1", d_flowx, d_flowy);
+    }
+
+    {
+        const double start = getTickCount();
+
+        GpuMat buf;
+        calcOpticalFlowBM(d_frame0, d_frame1, Size(7, 7), Size(1, 1), Size(21, 21), false, d_flowx, d_flowy, buf);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "BM : " << timeSec << " sec" << endl;
+
+        showFlow("BM", d_flowx, d_flowy);
+    }
+
+    {
+        const double start = getTickCount();
+
+        fastBM(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "Fast BM : " << timeSec << " sec" << endl;
+
+        showFlow("Fast BM", d_flowx, d_flowy);
+    }
+
+    imshow("Frame 0", frame0);
+    imshow("Frame 1", frame1);
     waitKey();
 
     return 0;

From 1a1f45424168a336a079e8f3aafcb4127eb6ea19 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 17 Dec 2012 11:15:45 +0400
Subject: [PATCH 143/155] updated gpu houghlines sample

---
 samples/gpu/houghlines.cpp | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp
index 0f1932672..4aa4cb153 100644
--- a/samples/gpu/houghlines.cpp
+++ b/samples/gpu/houghlines.cpp
@@ -37,8 +37,15 @@ int main(int argc, const char* argv[])
     Mat dst_gpu = dst_cpu.clone();
 
     vector<Vec4i> lines_cpu;
-    HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 60, 5);
-    cout << lines_cpu.size() << endl;
+    {
+        const double start = getTickCount();
+
+        HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 60, 5);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "CPU Time : " << timeSec * 1000 << " ms" << endl;
+        cout << "CPU Found : " << lines_cpu.size() << endl;
+    }
 
     for (size_t i = 0; i < lines_cpu.size(); ++i)
     {
@@ -49,7 +56,15 @@ int main(int argc, const char* argv[])
     GpuMat d_src(mask);
     GpuMat d_lines;
     HoughLinesBuf d_buf;
-    gpu::HoughLinesP(d_src, d_lines, d_buf, 1, CV_PI / 180, 50, 5);
+    {
+        const double start = getTickCount();
+
+        gpu::HoughLinesP(d_src, d_lines, d_buf, 1, CV_PI / 180, 50, 5);
+
+        const double timeSec = (getTickCount() - start) / getTickFrequency();
+        cout << "GPU Time : " << timeSec * 1000 << " ms" << endl;
+        cout << "GPU Found : " << d_lines.cols << endl;
+    }
     vector<Vec4i> lines_gpu;
     if (!d_lines.empty())
     {
@@ -57,7 +72,6 @@ int main(int argc, const char* argv[])
         Mat h_lines(1, d_lines.cols, CV_32SC4, &lines_gpu[0]);
         d_lines.download(h_lines);
     }
-    cout << lines_gpu.size() << endl;
 
     for (size_t i = 0; i < lines_gpu.size(); ++i)
     {

From dd8e442bda56d517d34fe90d8836e9cabcb80896 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Mon, 17 Dec 2012 17:03:39 +0400
Subject: [PATCH 144/155] replaced DeviceInfo().supports with deviceSupports

---
 modules/gpu/include/opencv2/gpu/gpu.hpp    |   5 -
 modules/gpu/src/arithm.cpp                 |  16 ++-
 modules/gpu/src/brute_force_matcher.cpp    |  84 +++++---------
 modules/gpu/src/cuda/bf_knnmatch.cu        | 123 ++++++++++----------
 modules/gpu/src/cuda/bf_match.cu           | 110 +++++++++---------
 modules/gpu/src/cuda/bf_radius_match.cu    | 104 ++++++++---------
 modules/gpu/src/cuda/fgd_bgfg.cu           |  12 +-
 modules/gpu/src/cuda/fgd_bgfg_common.hpp   |   2 +-
 modules/gpu/src/cuda/remap.cu              |  72 ++++++------
 modules/gpu/src/cuda/warp.cu               | 128 ++++++++++-----------
 modules/gpu/src/fast.cpp                   |   6 -
 modules/gpu/src/fgd_bgfg.cpp               |   7 +-
 modules/gpu/src/gftt.cpp                   |   3 -
 modules/gpu/src/hough.cpp                  |   3 +-
 modules/gpu/src/imgproc.cpp                |   5 +-
 modules/gpu/src/matrix_reductions.cpp      |  22 +++-
 modules/gpu/src/optical_flow_farneback.cpp |   4 +-
 modules/gpu/src/pyrlk.cpp                  |   9 +-
 modules/gpu/src/remap.cpp                  |   9 +-
 modules/gpu/src/split_merge.cpp            |   4 +-
 modules/gpu/src/surf.cpp                   |   3 -
 modules/gpu/src/warp.cpp                   |  20 ++--
 22 files changed, 352 insertions(+), 399 deletions(-)

diff --git a/modules/gpu/include/opencv2/gpu/gpu.hpp b/modules/gpu/include/opencv2/gpu/gpu.hpp
index 895afb274..c6ce2faff 100644
--- a/modules/gpu/include/opencv2/gpu/gpu.hpp
+++ b/modules/gpu/include/opencv2/gpu/gpu.hpp
@@ -1963,8 +1963,6 @@ private:
 
     GpuMat uPyr_[2];
     GpuMat vPyr_[2];
-
-    bool isDeviceArch11_;
 };
 
 
@@ -1981,7 +1979,6 @@ public:
         polyN = 5;
         polySigma = 1.1;
         flags = 0;
-        isDeviceArch11_ = !DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
     }
 
     int numLevels;
@@ -2029,8 +2026,6 @@ private:
     GpuMat frames_[2];
     GpuMat pyrLevel_[2], M_, bufM_, R_[2], blurredFrame_[2];
     std::vector<GpuMat> pyramid0_, pyramid1_;
-
-    bool isDeviceArch11_;
 };
 
 
diff --git a/modules/gpu/src/arithm.cpp b/modules/gpu/src/arithm.cpp
index 1a10bc32e..242febded 100644
--- a/modules/gpu/src/arithm.cpp
+++ b/modules/gpu/src/arithm.cpp
@@ -68,11 +68,16 @@ void cv::gpu::polarToCart(const GpuMat&, const GpuMat&, GpuMat&, GpuMat&, bool,
 void cv::gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags, Stream& stream)
 {
 #ifndef HAVE_CUBLAS
-    (void)src1; (void)src2; (void)alpha; (void)src3; (void)beta; (void)dst; (void)flags; (void)stream;
+    (void)src1;
+    (void)src2;
+    (void)alpha;
+    (void)src3;
+    (void)beta;
+    (void)dst;
+    (void)flags;
+    (void)stream;
     CV_Error(CV_StsNotImplemented, "The library was build without CUBLAS");
-
 #else
-
     // CUBLAS works with column-major matrices
 
     CV_Assert(src1.type() == CV_32FC1 || src1.type() == CV_32FC2 || src1.type() == CV_64FC1 || src1.type() == CV_64FC2);
@@ -80,7 +85,7 @@ void cv::gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const G
 
     if (src1.depth() == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
@@ -188,7 +193,6 @@ void cv::gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const G
     }
 
     cublasSafeCall( cublasDestroy_v2(handle) );
-
 #endif
 }
 
@@ -227,7 +231,7 @@ void cv::gpu::transpose(const GpuMat& src, GpuMat& dst, Stream& s)
     }
     else // if (src.elemSize() == 8)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
 
         NppStStreamHandler h(stream);
diff --git a/modules/gpu/src/brute_force_matcher.cpp b/modules/gpu/src/brute_force_matcher.cpp
index a04639715..095a64adb 100644
--- a/modules/gpu/src/brute_force_matcher.cpp
+++ b/modules/gpu/src/brute_force_matcher.cpp
@@ -88,71 +88,71 @@ namespace cv { namespace gpu { namespace device
     {
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
     }
 
     namespace bf_knnmatch
     {
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
 
         template <typename T> void match2L1_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void match2L2_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void match2Hamming_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
     }
 
     namespace bf_radius_match
     {
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream);
+            cudaStream_t stream);
     }
 }}}
 
@@ -202,7 +202,7 @@ void cv::gpu::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& trai
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
                              const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -238,10 +238,7 @@ void cv::gpu::BFMatcher_GPU::matchSingle(const GpuMat& query, const GpuMat& trai
     caller_t func = callers[query.depth()];
     CV_Assert(func != 0);
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    func(query, train, mask, trainIdx, distance, cc, StreamAccessor::getStream(stream));
+    func(query, train, mask, trainIdx, distance, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, vector<DMatch>& matches)
@@ -348,7 +345,7 @@ void cv::gpu::BFMatcher_GPU::matchCollection(const GpuMat& query, const GpuMat&
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
                              const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -383,10 +380,7 @@ void cv::gpu::BFMatcher_GPU::matchCollection(const GpuMat& query, const GpuMat&
     caller_t func = callers[query.depth()];
     CV_Assert(func != 0);
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    func(query, trainCollection, masks, trainIdx, imgIdx, distance, cc, StreamAccessor::getStream(stream));
+    func(query, trainCollection, masks, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, vector<DMatch>& matches)
@@ -462,7 +456,7 @@ void cv::gpu::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& t
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
                              const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -512,10 +506,7 @@ void cv::gpu::BFMatcher_GPU::knnMatchSingle(const GpuMat& query, const GpuMat& t
     caller_t func = callers[query.depth()];
     CV_Assert(func != 0);
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    func(query, train, k, mask, trainIdx, distance, allDist, cc, StreamAccessor::getStream(stream));
+    func(query, train, k, mask, trainIdx, distance, allDist, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance,
@@ -594,7 +585,7 @@ void cv::gpu::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuM
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
                              const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -634,10 +625,7 @@ void cv::gpu::BFMatcher_GPU::knnMatch2Collection(const GpuMat& query, const GpuM
     caller_t func = callers[query.depth()];
     CV_Assert(func != 0);
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    func(query, trainCollection, maskCollection, trainIdx, imgIdx, distance, cc, StreamAccessor::getStream(stream));
+    func(query, trainCollection, maskCollection, trainIdx, imgIdx, distance, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::knnMatch2Download(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance,
@@ -778,7 +766,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
                              const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -799,12 +787,6 @@ void cv::gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat
         matchHamming_gpu<int>, 0/*matchHamming_gpu<float>*/
     };
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-        CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
     const int nQuery = query.rows;
     const int nTrain = train.rows;
 
@@ -830,7 +812,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchSingle(const GpuMat& query, const GpuMat
     caller_t func = callers[query.depth()];
     CV_Assert(func != 0);
 
-    func(query, train, maxDistance, mask, trainIdx, distance, nMatches, cc, StreamAccessor::getStream(stream));
+    func(query, train, maxDistance, mask, trainIdx, distance, nMatches, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, const GpuMat& nMatches,
@@ -913,7 +895,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat&
 
     typedef void (*caller_t)(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
                              const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-                             int cc, cudaStream_t stream);
+                             cudaStream_t stream);
 
     static const caller_t callersL1[] =
     {
@@ -934,12 +916,6 @@ void cv::gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat&
         matchHamming_gpu<int>, 0/*matchHamming_gpu<float>*/
     };
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
-    if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-        CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
     const int nQuery = query.rows;
 
     CV_Assert(query.channels() == 1 && query.depth() < CV_64F);
@@ -968,7 +944,7 @@ void cv::gpu::BFMatcher_GPU::radiusMatchCollection(const GpuMat& query, GpuMat&
     vector<PtrStepSzb> masks_(masks.begin(), masks.end());
 
     func(query, &trains_[0], static_cast<int>(trains_.size()), maxDistance, masks_.size() == 0 ? 0 : &masks_[0],
-        trainIdx, imgIdx, distance, nMatches, cc, StreamAccessor::getStream(stream));
+        trainIdx, imgIdx, distance, nMatches, StreamAccessor::getStream(stream));
 }
 
 void cv::gpu::BFMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& imgIdx, const GpuMat& distance, const GpuMat& nMatches,
diff --git a/modules/gpu/src/cuda/bf_knnmatch.cu b/modules/gpu/src/cuda/bf_knnmatch.cu
index 491ac3111..49bc1dfcd 100644
--- a/modules/gpu/src/cuda/bf_knnmatch.cu
+++ b/modules/gpu/src/cuda/bf_knnmatch.cu
@@ -839,9 +839,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void match2Dispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>& train, const Mask& mask,
                               const PtrStepSzb& trainIdx, const PtrStepSzb& distance,
-                              int cc, cudaStream_t stream)
+                              cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolledCached<16, 64, Dist>(query, train, mask, static_cast< PtrStepSz<int2> >(trainIdx), static_cast< PtrStepSz<float2> > (distance), stream);
@@ -871,9 +870,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void match2Dispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>* trains, int n, const Mask& mask,
                               const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-                              int cc, cudaStream_t stream)
+                              cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, static_cast< PtrStepSz<int2> >(trainIdx), static_cast< PtrStepSz<int2> >(imgIdx), static_cast< PtrStepSz<float2> > (distance), stream);
@@ -1036,9 +1034,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void calcDistanceDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>& train, const Mask& mask,
                                     const PtrStepSzf& allDist,
-                                    int cc, cudaStream_t stream)
+                                    cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 calcDistanceUnrolled<16, 64, Dist>(query, train, mask, allDist, stream);
@@ -1125,7 +1122,7 @@ namespace cv { namespace gpu { namespace device
                 cudaSafeCall( cudaDeviceSynchronize() );
         }
 
-        void findKnnMatchDispatcher(int k, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int /*cc*/, cudaStream_t stream)
+        void findKnnMatchDispatcher(int k, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream)
         {
             findKnnMatch<256>(k, static_cast<PtrStepSzi>(trainIdx), static_cast<PtrStepSzf>(distance), allDist, stream);
         }
@@ -1136,16 +1133,16 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void matchDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>& train, int k, const Mask& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (k == 2)
             {
-                match2Dispatcher<Dist>(query, train, mask, trainIdx, distance, cc, stream);
+                match2Dispatcher<Dist>(query, train, mask, trainIdx, distance, stream);
             }
             else
             {
-                calcDistanceDispatcher<Dist>(query, train, mask, allDist, cc, stream);
-                findKnnMatchDispatcher(k, trainIdx, distance, allDist, cc, stream);
+                calcDistanceDispatcher<Dist>(query, train, mask, allDist, stream);
+                findKnnMatchDispatcher(k, trainIdx, distance, allDist, stream);
             }
         }
 
@@ -1154,103 +1151,103 @@ namespace cv { namespace gpu { namespace device
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
-                matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, stream);
             else
-                matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, stream);
         }
 
-        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
+        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
-                matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, stream);
             else
-                matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, stream);
         }
 
-        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
+        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, int k, const PtrStepSzb& mask,
             const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
-                matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, SingleMask(mask), trainIdx, distance, allDist, stream);
             else
-                matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, cc, stream);
+                matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), k, WithOutMask(), trainIdx, distance, allDist, stream);
         }
 
-        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, int cc, cudaStream_t stream);
+        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
+        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, int k, const PtrStepSzb& mask, const PtrStepSzb& trainIdx, const PtrStepSzb& distance, const PtrStepSzf& allDist, cudaStream_t stream);
 
         template <typename T> void match2L1_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (masks.data)
-                match2Dispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, stream);
             else
-                match2Dispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance,  stream);
         }
 
-        template void match2L1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2L1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2L1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2L1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2L1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2L1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
+        template void match2L1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2L1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2L1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2L1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2L1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2L1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
 
         template <typename T> void match2L2_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (masks.data)
-                match2Dispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, stream);
             else
-                match2Dispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, stream);
         }
 
-        //template void match2L2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2L2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2L2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2L2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2L2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2L2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
+        //template void match2L2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2L2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2L2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2L2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2L2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2L2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
 
         template <typename T> void match2Hamming_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
             const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (masks.data)
-                match2Dispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data), trainIdx, imgIdx, distance, stream);
             else
-                match2Dispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, cc, stream);
+                match2Dispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(), trainIdx, imgIdx, distance, stream);
         }
 
-        template void match2Hamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2Hamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2Hamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        //template void match2Hamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
-        template void match2Hamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, int cc, cudaStream_t stream);
+        template void match2Hamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2Hamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2Hamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        //template void match2Hamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
+        template void match2Hamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzb& trainIdx, const PtrStepSzb& imgIdx, const PtrStepSzb& distance, cudaStream_t stream);
     } // namespace bf_knnmatch
 }}} // namespace cv { namespace gpu { namespace device {
 
diff --git a/modules/gpu/src/cuda/bf_match.cu b/modules/gpu/src/cuda/bf_match.cu
index 9745dee82..5e64e31bd 100644
--- a/modules/gpu/src/cuda/bf_match.cu
+++ b/modules/gpu/src/cuda/bf_match.cu
@@ -558,9 +558,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void matchDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>& train, const Mask& mask,
                              const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-                             int cc, cudaStream_t stream)
+                             cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolledCached<16, 64, Dist>(query, train, mask, trainIdx, distance, stream);
@@ -590,9 +589,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void matchDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>* trains, int n, const Mask& mask,
                              const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-                             int cc, cudaStream_t stream)
+                             cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolledCached<16, 64, Dist>(query, trains, n, mask, trainIdx, imgIdx, distance, stream);
@@ -624,151 +622,151 @@ namespace cv { namespace gpu { namespace device
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
                                                const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-                                               int cc, cudaStream_t stream)
+                                               cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), SingleMask(mask),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), WithOutMask(),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
                                                const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-                                               int cc, cudaStream_t stream)
+                                               cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), SingleMask(mask),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), WithOutMask(),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, const PtrStepSzb& mask,
                                                     const PtrStepSzi& trainIdx, const PtrStepSzf& distance,
-                                                    int cc, cudaStream_t stream)
+                                                    cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), SingleMask(mask),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), WithOutMask(),
                     trainIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, cudaStream_t stream);
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
                                                const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-                                               int cc, cudaStream_t stream)
+                                                cudaStream_t stream)
         {
             if (masks.data)
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchL1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        template void matchL1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
                                                const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-                                               int cc, cudaStream_t stream)
+                                               cudaStream_t stream)
         {
             if (masks.data)
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        //template void matchL2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchL2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& maskCollection, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        //template void matchL2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchL2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchL2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& maskCollection, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks,
                                                     const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance,
-                                                    int cc, cudaStream_t stream)
+                                                    cudaStream_t stream)
         {
             if (masks.data)
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, MaskCollection(masks.data),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains.ptr(), trains.cols, WithOutMask(),
                     trainIdx, imgIdx, distance,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchHamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, int cc, cudaStream_t stream);
+        template void matchHamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchHamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchHamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        //template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
+        template void matchHamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb& trains, const PtrStepSz<PtrStepb>& masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, cudaStream_t stream);
     } // namespace bf_match
 }}} // namespace cv { namespace gpu { namespace device {
 
diff --git a/modules/gpu/src/cuda/bf_radius_match.cu b/modules/gpu/src/cuda/bf_radius_match.cu
index bb828829f..19ee94e33 100644
--- a/modules/gpu/src/cuda/bf_radius_match.cu
+++ b/modules/gpu/src/cuda/bf_radius_match.cu
@@ -274,9 +274,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T, typename Mask>
         void matchDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>& train, float maxDistance, const Mask& mask,
                              const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-                             int cc, cudaStream_t stream)
+                             cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolled<16, 64, Dist>(query, train, maxDistance, mask, trainIdx, distance, nMatches, stream);
@@ -306,9 +305,8 @@ namespace cv { namespace gpu { namespace device
         template <typename Dist, typename T>
         void matchDispatcher(const PtrStepSz<T>& query, const PtrStepSz<T>* trains, int n, float maxDistance, const PtrStepSzb* masks,
                              const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-                             int cc, cudaStream_t stream)
+                             cudaStream_t stream)
         {
-            (void)cc;
             if (query.cols <= 64)
             {
                 matchUnrolled<16, 64, Dist>(query, trains, n, maxDistance, masks, trainIdx, imgIdx, distance, nMatches, stream);
@@ -340,124 +338,124 @@ namespace cv { namespace gpu { namespace device
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, SingleMask(mask),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, WithOutMask(),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        template void matchL1_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL1_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, SingleMask(mask),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, WithOutMask(),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
         }
 
-        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        //template void matchL2_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL2_gpu<float >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb& train, float maxDistance, const PtrStepSzb& mask,
             const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             if (mask.data)
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, SingleMask(mask),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
             else
             {
                 matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), static_cast< PtrStepSz<T> >(train), maxDistance, WithOutMask(),
                     trainIdx, distance, nMatches,
-                    cc, stream);
+                    stream);
             }
         }
 
-        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        template void matchHamming_gpu<uchar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchHamming_gpu<schar >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchHamming_gpu<ushort>(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchHamming_gpu<short >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchHamming_gpu<int   >(const PtrStepSzb& queryDescs, const PtrStepSzb& trainDescs, float maxDistance, const PtrStepSzb& mask, const PtrStepSzi& trainIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
 
         template <typename T> void matchL1_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             matchDispatcher< L1Dist<T> >(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains, n, maxDistance, masks,
                 trainIdx, imgIdx, distance, nMatches,
-                cc, stream);
+                stream);
         }
 
-        template void matchL1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        template void matchL1_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL1_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL1_gpu<float >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
 
         template <typename T> void matchL2_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             matchDispatcher<L2Dist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains, n, maxDistance, masks,
                 trainIdx, imgIdx, distance, nMatches,
-                cc, stream);
+                stream);
         }
 
-        //template void matchL2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchL2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchL2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        //template void matchL2_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchL2_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchL2_gpu<float >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
 
         template <typename T> void matchHamming_gpu(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks,
             const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches,
-            int cc, cudaStream_t stream)
+            cudaStream_t stream)
         {
             matchDispatcher<HammingDist>(static_cast< PtrStepSz<T> >(query), (const PtrStepSz<T>*)trains, n, maxDistance, masks,
                 trainIdx, imgIdx, distance, nMatches,
-                cc, stream);
+                stream);
         }
 
-        template void matchHamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        //template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
-        template void matchHamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, int cc, cudaStream_t stream);
+        template void matchHamming_gpu<uchar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchHamming_gpu<schar >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchHamming_gpu<ushort>(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        //template void matchHamming_gpu<short >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
+        template void matchHamming_gpu<int   >(const PtrStepSzb& query, const PtrStepSzb* trains, int n, float maxDistance, const PtrStepSzb* masks, const PtrStepSzi& trainIdx, const PtrStepSzi& imgIdx, const PtrStepSzf& distance, const PtrStepSz<unsigned int>& nMatches, cudaStream_t stream);
     } // namespace bf_radius_match
 }}} // namespace cv { namespace gpu { namespace device
 
diff --git a/modules/gpu/src/cuda/fgd_bgfg.cu b/modules/gpu/src/cuda/fgd_bgfg.cu
index 6361e1811..a14da0f85 100644
--- a/modules/gpu/src/cuda/fgd_bgfg.cu
+++ b/modules/gpu/src/cuda/fgd_bgfg.cu
@@ -198,9 +198,9 @@ namespace bgfg
     void calcDiffHistogram_gpu(PtrStepSzb prevFrame, PtrStepSzb curFrame,
                                unsigned int* hist0, unsigned int* hist1, unsigned int* hist2,
                                unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2,
-                               int cc, cudaStream_t stream)
+                               bool cc20, cudaStream_t stream)
     {
-        const int HISTOGRAM_WARP_COUNT = cc < 20 ? 4 : 6;
+        const int HISTOGRAM_WARP_COUNT = cc20 ? 6 : 4;
         const int HISTOGRAM_THREADBLOCK_SIZE = HISTOGRAM_WARP_COUNT * WARP_SIZE;
 
         calcPartialHistogram<PT, CT><<<PARTIAL_HISTOGRAM_COUNT, HISTOGRAM_THREADBLOCK_SIZE, 0, stream>>>(
@@ -214,10 +214,10 @@ namespace bgfg
             cudaSafeCall( cudaDeviceSynchronize() );
     }
 
-    template void calcDiffHistogram_gpu<uchar3, uchar3>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, int cc, cudaStream_t stream);
-    template void calcDiffHistogram_gpu<uchar3, uchar4>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, int cc, cudaStream_t stream);
-    template void calcDiffHistogram_gpu<uchar4, uchar3>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, int cc, cudaStream_t stream);
-    template void calcDiffHistogram_gpu<uchar4, uchar4>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, int cc, cudaStream_t stream);
+    template void calcDiffHistogram_gpu<uchar3, uchar3>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, bool cc20, cudaStream_t stream);
+    template void calcDiffHistogram_gpu<uchar3, uchar4>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, bool cc20, cudaStream_t stream);
+    template void calcDiffHistogram_gpu<uchar4, uchar3>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, bool cc20, cudaStream_t stream);
+    template void calcDiffHistogram_gpu<uchar4, uchar4>(PtrStepSzb prevFrame, PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, bool cc20, cudaStream_t stream);
 
     /////////////////////////////////////////////////////////////////////////
     // calcDiffThreshMask
diff --git a/modules/gpu/src/cuda/fgd_bgfg_common.hpp b/modules/gpu/src/cuda/fgd_bgfg_common.hpp
index 433af80f7..986952e43 100644
--- a/modules/gpu/src/cuda/fgd_bgfg_common.hpp
+++ b/modules/gpu/src/cuda/fgd_bgfg_common.hpp
@@ -125,7 +125,7 @@ namespace bgfg
     void calcDiffHistogram_gpu(cv::gpu::PtrStepSzb prevFrame, cv::gpu::PtrStepSzb curFrame,
                                unsigned int* hist0, unsigned int* hist1, unsigned int* hist2,
                                unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2,
-                               int cc, cudaStream_t stream);
+                               bool cc20, cudaStream_t stream);
 
     template <typename PT, typename CT>
     void calcDiffThreshMask_gpu(cv::gpu::PtrStepSzb prevFrame, cv::gpu::PtrStepSzb curFrame, uchar3 bestThres, cv::gpu::PtrStepSzb changeMask, cudaStream_t stream);
diff --git a/modules/gpu/src/cuda/remap.cu b/modules/gpu/src/cuda/remap.cu
index dc80b132a..f40ada030 100644
--- a/modules/gpu/src/cuda/remap.cu
+++ b/modules/gpu/src/cuda/remap.cu
@@ -69,7 +69,7 @@ namespace cv { namespace gpu { namespace device
 
         template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherStream
         {
-            static void call(PtrStepSz<T> src, PtrStepSzf mapx, PtrStepSzf mapy, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int)
+            static void call(PtrStepSz<T> src, PtrStepSzf mapx, PtrStepSzf mapy, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool)
             {
                 typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type;
 
@@ -87,7 +87,7 @@ namespace cv { namespace gpu { namespace device
 
         template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcherNonStream
         {
-            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSzf mapx, PtrStepSzf mapy, PtrStepSz<T> dst, const float* borderValue, int)
+            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSzf mapx, PtrStepSzf mapy, PtrStepSz<T> dst, const float* borderValue, bool)
             {
                 (void)srcWhole;
                 (void)xoff;
@@ -124,10 +124,10 @@ namespace cv { namespace gpu { namespace device
             template <template <typename> class Filter, template <typename> class B> struct RemapDispatcherNonStream<Filter, B, type> \
             { \
                 static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSzf mapx, PtrStepSzf mapy, \
-                    PtrStepSz< type > dst, const float* borderValue, int cc) \
+                    PtrStepSz< type > dst, const float* borderValue, bool cc20) \
                 { \
                     typedef typename TypeVec<float, VecTraits< type >::cn>::vec_type work_type; \
-                    dim3 block(32, cc >= 20 ? 8 : 4); \
+                    dim3 block(32, cc20 ? 8 : 4); \
                     dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
                     bindTexture(&tex_remap_ ## type , srcWhole); \
                     tex_remap_ ## type ##_reader texSrc(xoff, yoff); \
@@ -142,7 +142,7 @@ namespace cv { namespace gpu { namespace device
             template <template <typename> class Filter> struct RemapDispatcherNonStream<Filter, BrdReplicate, type> \
             { \
                 static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSzf mapx, PtrStepSzf mapy, \
-                    PtrStepSz< type > dst, const float*, int) \
+                    PtrStepSz< type > dst, const float*, bool) \
                 { \
                     dim3 block(32, 8); \
                     dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
@@ -194,20 +194,20 @@ namespace cv { namespace gpu { namespace device
         template <template <typename> class Filter, template <typename> class B, typename T> struct RemapDispatcher
         {
             static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSzf mapx, PtrStepSzf mapy,
-                PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int cc)
+                PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool cc20)
             {
                 if (stream == 0)
-                    RemapDispatcherNonStream<Filter, B, T>::call(src, srcWhole, xoff, yoff, mapx, mapy, dst, borderValue, cc);
+                    RemapDispatcherNonStream<Filter, B, T>::call(src, srcWhole, xoff, yoff, mapx, mapy, dst, borderValue, cc20);
                 else
-                    RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc);
+                    RemapDispatcherStream<Filter, B, T>::call(src, mapx, mapy, dst, borderValue, stream, cc20);
             }
         };
 
         template <typename T> void remap_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap,
-            PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+            PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20)
         {
             typedef void (*caller_t)(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap,
-                PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int cc);
+                PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool cc20);
 
             static const caller_t callers[3][5] =
             {
@@ -235,40 +235,40 @@ namespace cv { namespace gpu { namespace device
             };
 
             callers[interpolation][borderMode](static_cast< PtrStepSz<T> >(src), static_cast< PtrStepSz<T> >(srcWhole), xoff, yoff, xmap, ymap,
-                static_cast< PtrStepSz<T> >(dst), borderValue, stream, cc);
+                static_cast< PtrStepSz<T> >(dst), borderValue, stream, cc20);
         }
 
-        template void remap_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void remap_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void remap_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void remap_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void remap_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void remap_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void remap_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void remap_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void remap_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void remap_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void remap_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void remap_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void remap_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void remap_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void remap_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void remap_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
     } // namespace imgproc
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/cuda/warp.cu b/modules/gpu/src/cuda/warp.cu
index fbc2ec37e..49130d940 100644
--- a/modules/gpu/src/cuda/warp.cu
+++ b/modules/gpu/src/cuda/warp.cu
@@ -140,7 +140,7 @@ namespace cv { namespace gpu { namespace device
 
         template <class Transform, template <typename> class Filter, template <typename> class B, typename T> struct WarpDispatcherStream
         {
-            static void call(PtrStepSz<T> src, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int)
+            static void call(PtrStepSz<T> src, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool)
             {
                 typedef typename TypeVec<float, VecTraits<T>::cn>::vec_type work_type;
 
@@ -158,7 +158,7 @@ namespace cv { namespace gpu { namespace device
 
         template <class Transform, template <typename> class Filter, template <typename> class B, typename T> struct WarpDispatcherNonStream
         {
-            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, int)
+            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, bool)
             {
                 (void)xoff;
                 (void)yoff;
@@ -195,10 +195,10 @@ namespace cv { namespace gpu { namespace device
             }; \
             template <class Transform, template <typename> class Filter, template <typename> class B> struct WarpDispatcherNonStream<Transform, Filter, B, type> \
             { \
-                static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSz< type > dst, const float* borderValue, int cc) \
+                static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSz< type > dst, const float* borderValue, bool cc20) \
                 { \
                     typedef typename TypeVec<float, VecTraits< type >::cn>::vec_type work_type; \
-                    dim3 block(32, cc >= 20 ? 8 : 4); \
+                    dim3 block(32, cc20 ? 8 : 4); \
                     dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
                     bindTexture(&tex_warp_ ## type , srcWhole); \
                     tex_warp_ ## type ##_reader texSrc(xoff, yoff); \
@@ -212,7 +212,7 @@ namespace cv { namespace gpu { namespace device
             }; \
             template <class Transform, template <typename> class Filter> struct WarpDispatcherNonStream<Transform, Filter, BrdReplicate, type> \
             { \
-                static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSz< type > dst, const float*, int) \
+                static void call(PtrStepSz< type > src, PtrStepSz< type > srcWhole, int xoff, int yoff, PtrStepSz< type > dst, const float*, bool) \
                 { \
                     dim3 block(32, 8); \
                     dim3 grid(divUp(dst.cols, block.x), divUp(dst.rows, block.y)); \
@@ -263,20 +263,20 @@ namespace cv { namespace gpu { namespace device
 
         template <class Transform, template <typename> class Filter, template <typename> class B, typename T> struct WarpDispatcher
         {
-            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int cc)
+            static void call(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool cc20)
             {
                 if (stream == 0)
-                    WarpDispatcherNonStream<Transform, Filter, B, T>::call(src, srcWhole, xoff, yoff, dst, borderValue, cc);
+                    WarpDispatcherNonStream<Transform, Filter, B, T>::call(src, srcWhole, xoff, yoff, dst, borderValue, cc20);
                 else
-                    WarpDispatcherStream<Transform, Filter, B, T>::call(src, dst, borderValue, stream, cc);
+                    WarpDispatcherStream<Transform, Filter, B, T>::call(src, dst, borderValue, stream, cc20);
             }
         };
 
         template <class Transform, typename T>
         void warp_caller(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzb dst, int interpolation,
-                         int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+                         int borderMode, const float* borderValue, cudaStream_t stream, bool cc20)
         {
-            typedef void (*func_t)(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, int cc);
+            typedef void (*func_t)(PtrStepSz<T> src, PtrStepSz<T> srcWhole, int xoff, int yoff, PtrStepSz<T> dst, const float* borderValue, cudaStream_t stream, bool cc20);
 
             static const func_t funcs[3][5] =
             {
@@ -304,86 +304,86 @@ namespace cv { namespace gpu { namespace device
             };
 
             funcs[interpolation][borderMode](static_cast< PtrStepSz<T> >(src), static_cast< PtrStepSz<T> >(srcWhole), xoff, yoff,
-                static_cast< PtrStepSz<T> >(dst), borderValue, stream, cc);
+                static_cast< PtrStepSz<T> >(dst), borderValue, stream, cc20);
         }
 
         template <typename T> void warpAffine_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
-                                                  int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+                                                  int borderMode, const float* borderValue, cudaStream_t stream, bool cc20)
         {
             cudaSafeCall( cudaMemcpyToSymbol(c_warpMat, coeffs, 2 * 3 * sizeof(float)) );
 
-            warp_caller<AffineTransform, T>(src, srcWhole, xoff, yoff, dst, interpolation, borderMode, borderValue, stream, cc);
+            warp_caller<AffineTransform, T>(src, srcWhole, xoff, yoff, dst, interpolation, borderMode, borderValue, stream, cc20);
         }
 
-        template void warpAffine_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpAffine_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void warpAffine_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void warpAffine_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpAffine_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpAffine_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpAffine_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpAffine_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void warpAffine_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void warpAffine_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpAffine_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpAffine_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpAffine_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpAffine_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpAffine_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpAffine_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
         template <typename T> void warpPerspective_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation,
-                                                  int borderMode, const float* borderValue, cudaStream_t stream, int cc)
+                                                  int borderMode, const float* borderValue, cudaStream_t stream, bool cc20)
         {
             cudaSafeCall( cudaMemcpyToSymbol(c_warpMat, coeffs, 3 * 3 * sizeof(float)) );
 
-            warp_caller<PerspectiveTransform, T>(src, srcWhole, xoff, yoff, dst, interpolation, borderMode, borderValue, stream, cc);
+            warp_caller<PerspectiveTransform, T>(src, srcWhole, xoff, yoff, dst, interpolation, borderMode, borderValue, stream, cc20);
         }
 
-        template void warpPerspective_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpPerspective_gpu<uchar >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<uchar2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<uchar3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<uchar4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void warpPerspective_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void warpPerspective_gpu<schar>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<char2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<char3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<char4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpPerspective_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpPerspective_gpu<ushort >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<ushort2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<ushort3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<ushort4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpPerspective_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpPerspective_gpu<short >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<short2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<short3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<short4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        //template void warpPerspective_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        //template void warpPerspective_gpu<int >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<int2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<int3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<int4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
-        template void warpPerspective_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        //template void warpPerspective_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
-        template void warpPerspective_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        template void warpPerspective_gpu<float >(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        //template void warpPerspective_gpu<float2>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<float3>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
+        template void warpPerspective_gpu<float4>(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
     } // namespace imgproc
 }}} // namespace cv { namespace gpu { namespace device
 
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/src/fast.cpp b/modules/gpu/src/fast.cpp
index d09210da4..f8b3b9887 100644
--- a/modules/gpu/src/fast.cpp
+++ b/modules/gpu/src/fast.cpp
@@ -125,9 +125,6 @@ int cv::gpu::FAST_GPU::calcKeyPointsLocation(const GpuMat& img, const GpuMat& ma
     CV_Assert(img.type() == CV_8UC1);
     CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == img.size()));
 
-    if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-        CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
     int maxKeypoints = static_cast<int>(keypointsRatio * img.size().area());
 
     ensureSizeIsEnough(1, maxKeypoints, CV_16SC2, kpLoc_);
@@ -148,9 +145,6 @@ int cv::gpu::FAST_GPU::getKeyPoints(GpuMat& keypoints)
 {
     using namespace cv::gpu::device::fast;
 
-    if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-        CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
     if (count_ == 0)
         return 0;
 
diff --git a/modules/gpu/src/fgd_bgfg.cpp b/modules/gpu/src/fgd_bgfg.cpp
index 6bd7cab29..e0f695d44 100644
--- a/modules/gpu/src/fgd_bgfg.cpp
+++ b/modules/gpu/src/fgd_bgfg.cpp
@@ -336,7 +336,7 @@ namespace
 {
     void calcDiffHistogram(const cv::gpu::GpuMat& prevFrame, const cv::gpu::GpuMat& curFrame, cv::gpu::GpuMat& hist, cv::gpu::GpuMat& histBuf)
     {
-        typedef void (*func_t)(cv::gpu::PtrStepSzb prevFrame, cv::gpu::PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, int cc, cudaStream_t stream);
+        typedef void (*func_t)(cv::gpu::PtrStepSzb prevFrame, cv::gpu::PtrStepSzb curFrame, unsigned int* hist0, unsigned int* hist1, unsigned int* hist2, unsigned int* partialBuf0, unsigned int* partialBuf1, unsigned int* partialBuf2, bool cc20, cudaStream_t stream);
         static const func_t funcs[4][4] =
         {
             {0,0,0,0},
@@ -348,14 +348,11 @@ namespace
         hist.create(3, 256, CV_32SC1);
         histBuf.create(3, bgfg::PARTIAL_HISTOGRAM_COUNT * bgfg::HISTOGRAM_BIN_COUNT, CV_32SC1);
 
-        cv::gpu::DeviceInfo devInfo;
-        int cc = devInfo.majorVersion() * 10 + devInfo.minorVersion();
-
         funcs[prevFrame.channels() - 1][curFrame.channels() - 1](
                     prevFrame, curFrame,
                     hist.ptr<unsigned int>(0), hist.ptr<unsigned int>(1), hist.ptr<unsigned int>(2),
                     histBuf.ptr<unsigned int>(0), histBuf.ptr<unsigned int>(1), histBuf.ptr<unsigned int>(2),
-                    cc, 0);
+                    cv::gpu::deviceSupports(cv::gpu::FEATURE_SET_COMPUTE_20), 0);
     }
 
     void calcRelativeVariance(unsigned int hist[3 * 256], double relativeVariance[3][bgfg::HISTOGRAM_BIN_COUNT])
diff --git a/modules/gpu/src/gftt.cpp b/modules/gpu/src/gftt.cpp
index 0c8f165ae..6bb73de75 100644
--- a/modules/gpu/src/gftt.cpp
+++ b/modules/gpu/src/gftt.cpp
@@ -68,9 +68,6 @@ void cv::gpu::GoodFeaturesToTrackDetector_GPU::operator ()(const GpuMat& image,
     CV_Assert(qualityLevel > 0 && minDistance >= 0 && maxCorners >= 0);
     CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == image.size()));
 
-    if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-        CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
     ensureSizeIsEnough(image.size(), CV_32F, eig_);
 
     if (useHarrisDetector)
diff --git a/modules/gpu/src/hough.cpp b/modules/gpu/src/hough.cpp
index b1751076c..1b9c786c3 100644
--- a/modules/gpu/src/hough.cpp
+++ b/modules/gpu/src/hough.cpp
@@ -343,9 +343,8 @@ void cv::gpu::HoughCircles(const GpuMat& src, GpuMat& circles, HoughCirclesBuf&
 
     ensureSizeIsEnough(1, maxCircles, CV_32FC3, circles);
 
-    DeviceInfo devInfo;
     const int circlesCount = circlesAccumRadius_gpu(centers, centersCount, srcPoints, pointsCount, circles.ptr<float3>(), maxCircles,
-                                                    dp, minRadius, maxRadius, votesThreshold, devInfo.supports(FEATURE_SET_COMPUTE_20));
+                                                    dp, minRadius, maxRadius, votesThreshold, deviceSupports(FEATURE_SET_COMPUTE_20));
 
     if (circlesCount > 0)
         circles.cols = circlesCount;
diff --git a/modules/gpu/src/imgproc.cpp b/modules/gpu/src/imgproc.cpp
index d430eceae..283ca7cd7 100644
--- a/modules/gpu/src/imgproc.cpp
+++ b/modules/gpu/src/imgproc.cpp
@@ -544,13 +544,12 @@ void cv::gpu::integralBuffered(const GpuMat& src, GpuMat& sum, GpuMat& buffer, S
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    DeviceInfo info;
     cv::Size whole;
     cv::Point offset;
 
     src.locateROI(whole, offset);
 
-    if (info.supports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048
+    if (deviceSupports(WARP_SHUFFLE_FUNCTIONS) && src.cols <= 2048
         && offset.x % 16 == 0 && ((src.cols + 63) / 64) * 64 <= (static_cast<int>(src.step) - offset.x))
     {
         ensureSizeIsEnough(((src.rows + 7) / 8) * 8, ((src.cols + 63) / 64) * 64, CV_32SC1, buffer);
@@ -1489,7 +1488,7 @@ void cv::gpu::Canny(const GpuMat& src, CannyBuf& buf, GpuMat& dst, double low_th
 
     CV_Assert(src.type() == CV_8UC1);
 
-    if (!TargetArchs::builtWith(SHARED_ATOMICS) || !DeviceInfo().supports(SHARED_ATOMICS))
+    if (!deviceSupports(SHARED_ATOMICS))
         CV_Error(CV_StsNotImplemented, "The device doesn't support shared atomics");
 
     if( low_thresh > high_thresh )
diff --git a/modules/gpu/src/matrix_reductions.cpp b/modules/gpu/src/matrix_reductions.cpp
index 9e6d9751f..4295644c7 100644
--- a/modules/gpu/src/matrix_reductions.cpp
+++ b/modules/gpu/src/matrix_reductions.cpp
@@ -118,7 +118,7 @@ void cv::gpu::meanStdDev(const GpuMat& src, Scalar& mean, Scalar& stddev, GpuMat
 {
     CV_Assert(src.type() == CV_8UC1);
 
-    if (!TargetArchs::builtWith(FEATURE_SET_COMPUTE_13) || !DeviceInfo().supports(FEATURE_SET_COMPUTE_13))
+    if (!deviceSupports(FEATURE_SET_COMPUTE_13))
         CV_Error(CV_StsNotImplemented, "Not sufficient compute capebility");
 
     NppiSize sz;
@@ -240,7 +240,7 @@ Scalar cv::gpu::sum(const GpuMat& src, GpuMat& buf)
 
     if (src.depth() == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
@@ -277,6 +277,12 @@ Scalar cv::gpu::absSum(const GpuMat& src, GpuMat& buf)
         {0, ::sum::runAbs<double, 1>, ::sum::runAbs<double, 2>, ::sum::runAbs<double, 3>, ::sum::runAbs<double, 4>}
     };
 
+    if (src.depth() == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
+
     Size buf_size;
     ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
@@ -310,6 +316,12 @@ Scalar cv::gpu::sqrSum(const GpuMat& src, GpuMat& buf)
         {0, ::sum::runSqr<double, 1>, ::sum::runSqr<double, 2>, ::sum::runSqr<double, 3>, ::sum::runSqr<double, 4>}
     };
 
+    if (src.depth() == CV_64F)
+    {
+        if (!deviceSupports(NATIVE_DOUBLE))
+            CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
+    }
+
     Size buf_size;
     ::sum::getBufSize(src.cols, src.rows, src.channels(), buf_size.width, buf_size.height);
     ensureSizeIsEnough(buf_size, CV_8U, buf);
@@ -359,7 +371,7 @@ void cv::gpu::minMax(const GpuMat& src, double* minVal, double* maxVal, const Gp
 
     if (src.depth() == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
@@ -410,7 +422,7 @@ void cv::gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point
 
     if (src.depth() == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
@@ -461,7 +473,7 @@ int cv::gpu::countNonZero(const GpuMat& src, GpuMat& buf)
 
     if (src.depth() == CV_64F)
     {
-        if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+        if (!deviceSupports(NATIVE_DOUBLE))
             CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
     }
 
diff --git a/modules/gpu/src/optical_flow_farneback.cpp b/modules/gpu/src/optical_flow_farneback.cpp
index 3a0a912ac..91056a67a 100644
--- a/modules/gpu/src/optical_flow_farneback.cpp
+++ b/modules/gpu/src/optical_flow_farneback.cpp
@@ -172,7 +172,7 @@ void cv::gpu::FarnebackOpticalFlow::updateFlow_boxFilter(
         const GpuMat& R0, const GpuMat& R1, GpuMat& flowx, GpuMat &flowy,
         GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[])
 {
-    if (!isDeviceArch11_)
+    if (deviceSupports(FEATURE_SET_COMPUTE_12))
         device::optflow_farneback::boxFilter5Gpu(M, blockSize/2, bufM, S(streams[0]));
     else
         device::optflow_farneback::boxFilter5Gpu_CC11(M, blockSize/2, bufM, S(streams[0]));
@@ -191,7 +191,7 @@ void cv::gpu::FarnebackOpticalFlow::updateFlow_gaussianBlur(
         const GpuMat& R0, const GpuMat& R1, GpuMat& flowx, GpuMat& flowy,
         GpuMat& M, GpuMat &bufM, int blockSize, bool updateMatrices, Stream streams[])
 {
-    if (!isDeviceArch11_)
+    if (deviceSupports(FEATURE_SET_COMPUTE_12))
         device::optflow_farneback::gaussianBlur5Gpu(
                     M, blockSize/2, bufM, BORDER_REPLICATE_GPU, S(streams[0]));
     else
diff --git a/modules/gpu/src/pyrlk.cpp b/modules/gpu/src/pyrlk.cpp
index d5debbe0b..49a6c5a88 100644
--- a/modules/gpu/src/pyrlk.cpp
+++ b/modules/gpu/src/pyrlk.cpp
@@ -74,22 +74,21 @@ cv::gpu::PyrLKOpticalFlow::PyrLKOpticalFlow()
     maxLevel = 3;
     iters = 30;
     useInitialFlow = false;
-    isDeviceArch11_ = !DeviceInfo().supports(FEATURE_SET_COMPUTE_12);
 }
 
 namespace
 {
-    void calcPatchSize(cv::Size winSize, dim3& block, dim3& patch, bool isDeviceArch11)
+    void calcPatchSize(cv::Size winSize, dim3& block, dim3& patch)
     {
         if (winSize.width > 32 && winSize.width > 2 * winSize.height)
         {
-            block.x = isDeviceArch11 ? 16 : 32;
+            block.x = deviceSupports(FEATURE_SET_COMPUTE_12) ? 32 : 16;
             block.y = 8;
         }
         else
         {
             block.x = 16;
-            block.y = isDeviceArch11 ? 8 : 16;
+            block.y = deviceSupports(FEATURE_SET_COMPUTE_12) ? 16 : 8;
         }
 
         patch.x = (winSize.width  + block.x - 1) / block.x;
@@ -110,7 +109,7 @@ void cv::gpu::PyrLKOpticalFlow::sparse(const GpuMat& prevImg, const GpuMat& next
     }
 
     dim3 block, patch;
-    calcPatchSize(winSize, block, patch, isDeviceArch11_);
+    calcPatchSize(winSize, block, patch);
 
     CV_Assert(prevImg.channels() == 1 || prevImg.channels() == 3 || prevImg.channels() == 4);
     CV_Assert(prevImg.size() == nextImg.size() && prevImg.type() == nextImg.type());
diff --git a/modules/gpu/src/remap.cpp b/modules/gpu/src/remap.cpp
index f4d51f187..4b8728633 100644
--- a/modules/gpu/src/remap.cpp
+++ b/modules/gpu/src/remap.cpp
@@ -54,7 +54,7 @@ namespace cv { namespace gpu { namespace device
     {
         template <typename T>
         void remap_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst,
-                       int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+                       int interpolation, int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
     }
 }}}
 
@@ -63,7 +63,7 @@ void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const Gp
     using namespace cv::gpu::device::imgproc;
 
     typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, PtrStepSzf xmap, PtrStepSzf ymap, PtrStepSzb dst, int interpolation,
-        int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+        int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
     static const func_t funcs[6][4] =
     {
@@ -91,15 +91,12 @@ void cv::gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const Gp
     Scalar_<float> borderValueFloat;
     borderValueFloat = borderValue;
 
-    DeviceInfo info;
-    int cc = info.majorVersion() * 10 + info.minorVersion();
-
     Size wholeSize;
     Point ofs;
     src.locateROI(wholeSize, ofs);
 
     func(src, PtrStepSzb(wholeSize.height, wholeSize.width, src.datastart, src.step), ofs.x, ofs.y, xmap, ymap,
-        dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(stream), cc);
+        dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(stream), deviceSupports(FEATURE_SET_COMPUTE_20));
 }
 
 #endif // HAVE_CUDA
diff --git a/modules/gpu/src/split_merge.cpp b/modules/gpu/src/split_merge.cpp
index 0aa0e5896..434c6e85c 100644
--- a/modules/gpu/src/split_merge.cpp
+++ b/modules/gpu/src/split_merge.cpp
@@ -78,7 +78,7 @@ namespace
 
         if (depth == CV_64F)
         {
-            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+            if (!deviceSupports(NATIVE_DOUBLE))
                 CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
         }
 
@@ -122,7 +122,7 @@ namespace
 
         if (depth == CV_64F)
         {
-            if (!TargetArchs::builtWith(NATIVE_DOUBLE) || !DeviceInfo().supports(NATIVE_DOUBLE))
+            if (!deviceSupports(NATIVE_DOUBLE))
                 CV_Error(CV_StsUnsupportedFormat, "The device doesn't support double");
         }
 
diff --git a/modules/gpu/src/surf.cpp b/modules/gpu/src/surf.cpp
index ac62617f3..024087fe5 100644
--- a/modules/gpu/src/surf.cpp
+++ b/modules/gpu/src/surf.cpp
@@ -121,9 +121,6 @@ namespace
             CV_Assert(mask.empty() || (mask.size() == img.size() && mask.type() == CV_8UC1));
             CV_Assert(surf_.nOctaves > 0 && surf_.nOctaveLayers > 0);
 
-            if (!TargetArchs::builtWith(GLOBAL_ATOMICS) || !DeviceInfo().supports(GLOBAL_ATOMICS))
-                CV_Error(CV_StsNotImplemented, "The device doesn't support global atomics");
-
             const int min_size = calcSize(surf_.nOctaves - 1, 0);
             CV_Assert(img_rows - min_size >= 0);
             CV_Assert(img_cols - min_size >= 0);
diff --git a/modules/gpu/src/warp.cpp b/modules/gpu/src/warp.cpp
index e663b8952..0fb19adda 100644
--- a/modules/gpu/src/warp.cpp
+++ b/modules/gpu/src/warp.cpp
@@ -61,13 +61,13 @@ namespace cv { namespace gpu { namespace device
 
         template <typename T>
         void warpAffine_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
-                            int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+                            int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
         void buildWarpPerspectiveMaps_gpu(float coeffs[3 * 3], PtrStepSzf xmap, PtrStepSzf ymap, cudaStream_t stream);
 
         template <typename T>
         void warpPerspective_gpu(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[3 * 3], PtrStepSzb dst, int interpolation,
-                            int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+                            int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
     }
 }}}
 
@@ -166,7 +166,7 @@ namespace
             cv::gpu::NppStreamHandler h(stream);
 
             nppSafeCall( func(src.ptr<npp_t>(), srcsz, static_cast<int>(src.step), srcroi,
-                              dst.ptr<npp_t>(), static_cast<int>(dst.step), dstroi, 
+                              dst.ptr<npp_t>(), static_cast<int>(dst.step), dstroi,
                               coeffs, npp_inter[interpolation]) );
 
             if (stream == 0)
@@ -277,7 +277,7 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
         using namespace cv::gpu::device::imgproc;
 
         typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
-            int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+            int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
         static const func_t funcs[6][4] =
         {
@@ -310,11 +310,8 @@ void cv::gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsiz
         Scalar_<float> borderValueFloat;
         borderValueFloat = borderValue;
 
-        DeviceInfo info;
-        int cc = info.majorVersion() * 10 + info.minorVersion();
-
         func(src, PtrStepSzb(wholeSize.height, wholeSize.width, src.datastart, src.step), ofs.x, ofs.y, coeffs,
-            dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(s), cc);
+            dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(s), deviceSupports(FEATURE_SET_COMPUTE_20));
     }
 }
 
@@ -420,7 +417,7 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
         using namespace cv::gpu::device::imgproc;
 
         typedef void (*func_t)(PtrStepSzb src, PtrStepSzb srcWhole, int xoff, int yoff, float coeffs[2 * 3], PtrStepSzb dst, int interpolation,
-            int borderMode, const float* borderValue, cudaStream_t stream, int cc);
+            int borderMode, const float* borderValue, cudaStream_t stream, bool cc20);
 
         static const func_t funcs[6][4] =
         {
@@ -453,11 +450,8 @@ void cv::gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size
         Scalar_<float> borderValueFloat;
         borderValueFloat = borderValue;
 
-        DeviceInfo info;
-        int cc = info.majorVersion() * 10 + info.minorVersion();
-
         func(src, PtrStepSzb(wholeSize.height, wholeSize.width, src.datastart, src.step), ofs.x, ofs.y, coeffs,
-            dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(s), cc);
+            dst, interpolation, gpuBorderType, borderValueFloat.val, StreamAccessor::getStream(s), deviceSupports(FEATURE_SET_COMPUTE_20));
     }
 }
 

From bac94f85c13f960934301d73be0f285b2f0071c2 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 18 Dec 2012 13:50:19 +0400
Subject: [PATCH 145/155] fixed printCudaDeviceInfo for 3.5 CC (Patch #2641)

---
 modules/core/src/gpumat.cpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
index 49f6de389..f43d76b4c 100644
--- a/modules/core/src/gpumat.cpp
+++ b/modules/core/src/gpumat.cpp
@@ -401,7 +401,7 @@ namespace
             int Cores;
         } SMtoCores;
 
-        SMtoCores gpuArchCoresPerSM[] =  { { 0x10,  8 }, { 0x11,  8 }, { 0x12,  8 }, { 0x13,  8 }, { 0x20, 32 }, { 0x21, 48 }, {0x30, 192}, { -1, -1 }  };
+        SMtoCores gpuArchCoresPerSM[] =  { { 0x10,  8 }, { 0x11,  8 }, { 0x12,  8 }, { 0x13,  8 }, { 0x20, 32 }, { 0x21, 48 }, {0x30, 192}, {0x35, 192}, { -1, -1 }  };
 
         int index = 0;
         while (gpuArchCoresPerSM[index].SM != -1)
@@ -410,7 +410,7 @@ namespace
                 return gpuArchCoresPerSM[index].Cores;
             index++;
         }
-        printf("MapSMtoCores undefined SMversion %d.%d!\n", major, minor);
+
         return -1;
     }
 }
@@ -448,9 +448,11 @@ void cv::gpu::printCudaDeviceInfo(int device)
         printf("  CUDA Driver Version / Runtime Version          %d.%d / %d.%d\n", driverVersion/1000, driverVersion%100, runtimeVersion/1000, runtimeVersion%100);
         printf("  CUDA Capability Major/Minor version number:    %d.%d\n", prop.major, prop.minor);
         printf("  Total amount of global memory:                 %.0f MBytes (%llu bytes)\n", (float)prop.totalGlobalMem/1048576.0f, (unsigned long long) prop.totalGlobalMem);
-        printf("  (%2d) Multiprocessors x (%2d) CUDA Cores/MP:     %d CUDA Cores\n",
-            prop.multiProcessorCount, convertSMVer2Cores(prop.major, prop.minor),
-            convertSMVer2Cores(prop.major, prop.minor) * prop.multiProcessorCount);
+
+        int cores = convertSMVer2Cores(prop.major, prop.minor);
+        if (cores > 0)
+            printf("  (%2d) Multiprocessors x (%2d) CUDA Cores/MP:     %d CUDA Cores\n", prop.multiProcessorCount, cores, cores * prop.multiProcessorCount);
+
         printf("  GPU Clock Speed:                               %.2f GHz\n", prop.clockRate * 1e-6f);
 
         printf("  Max Texture Dimension Size (x,y,z)             1D=(%d), 2D=(%d,%d), 3D=(%d,%d,%d)\n",

From 0973e86d8a3c9c47a0fb99b094ca9f453e880cdc Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 18 Dec 2012 13:56:21 +0400
Subject: [PATCH 146/155] fixed printShortCudaDeviceInfo for new CC

---
 modules/core/src/gpumat.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/modules/core/src/gpumat.cpp b/modules/core/src/gpumat.cpp
index f43d76b4c..43f4d613b 100644
--- a/modules/core/src/gpumat.cpp
+++ b/modules/core/src/gpumat.cpp
@@ -514,7 +514,12 @@ void cv::gpu::printShortCudaDeviceInfo(int device)
 
         const char *arch_str = prop.major < 2 ? " (not Fermi)" : "";
         printf("Device %d:  \"%s\"  %.0fMb", dev, prop.name, (float)prop.totalGlobalMem/1048576.0f);
-        printf(", sm_%d%d%s, %d cores", prop.major, prop.minor, arch_str, convertSMVer2Cores(prop.major, prop.minor) * prop.multiProcessorCount);
+        printf(", sm_%d%d%s", prop.major, prop.minor, arch_str);
+
+        int cores = convertSMVer2Cores(prop.major, prop.minor);
+        if (cores > 0)
+            printf(", %d cores", cores * prop.multiProcessorCount);
+
         printf(", Driver/Runtime ver.%d.%d/%d.%d\n", driverVersion/1000, driverVersion%100, runtimeVersion/1000, runtimeVersion%100);
     }
     fflush(stdout);

From ab25fe9e377fdbd69c916d5124483fa26e4a7835 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 18 Dec 2012 16:59:00 +0400
Subject: [PATCH 147/155] call resetDevice if gpu test fails

---
 modules/gpu/app/nv_perf_test/main.cpp      |  176 +-
 modules/gpu/perf/perf_calib3d.cpp          |  246 +-
 modules/gpu/perf/perf_core.cpp             |  963 +++++--
 modules/gpu/perf/perf_denoising.cpp        |  112 +-
 modules/gpu/perf/perf_features2d.cpp       |  196 +-
 modules/gpu/perf/perf_filters.cpp          |  248 +-
 modules/gpu/perf/perf_imgproc.cpp          | 1201 +++++----
 modules/gpu/perf/perf_labeling.cpp         |   36 +-
 modules/gpu/perf/perf_matop.cpp            |  104 +-
 modules/gpu/perf/perf_objdetect.cpp        |  114 +-
 modules/gpu/perf/perf_softcascade.cpp      |  274 +-
 modules/gpu/perf/perf_video.cpp            |  788 +++---
 modules/gpu/test/nvidia/main_nvidia.cpp    |    6 +-
 modules/gpu/test/test_calib3d.cpp          |  282 ++-
 modules/gpu/test/test_color.cpp            | 2598 ++++++++++++-------
 modules/gpu/test/test_copy_make_border.cpp |   22 +-
 modules/gpu/test/test_core.cpp             | 2672 ++++++++++++--------
 modules/gpu/test/test_denoising.cpp        |  111 +-
 modules/gpu/test/test_features2d.cpp       |  888 +++----
 modules/gpu/test/test_filters.cpp          |  218 +-
 modules/gpu/test/test_global_motion.cpp    |   52 +-
 modules/gpu/test/test_gpumat.cpp           |  318 ++-
 modules/gpu/test/test_hough.cpp            |  228 +-
 modules/gpu/test/test_imgproc.cpp          |  726 ++++--
 modules/gpu/test/test_labeling.cpp         |   34 +-
 modules/gpu/test/test_nvidia.cpp           |  139 +-
 modules/gpu/test/test_objdetect.cpp        |  355 +--
 modules/gpu/test/test_opengl.cpp           |  620 +++--
 modules/gpu/test/test_pyramids.cpp         |   40 +-
 modules/gpu/test/test_remap.cpp            |   22 +-
 modules/gpu/test/test_resize.cpp           |   62 +-
 modules/gpu/test/test_softcascade.cpp      |  277 +-
 modules/gpu/test/test_threshold.cpp        |   24 +-
 modules/gpu/test/test_video.cpp            | 1010 ++++----
 modules/gpu/test/test_warp_affine.cpp      |   94 +-
 modules/gpu/test/test_warp_perspective.cpp |   90 +-
 36 files changed, 9551 insertions(+), 5795 deletions(-)

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
index 928b30a19..96a5151c6 100644
--- a/modules/gpu/app/nv_perf_test/main.cpp
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -92,15 +92,23 @@ PERF_TEST_P(Image, HoughLinesP,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image(image);
-        cv::gpu::GpuMat d_lines;
-        cv::gpu::HoughLinesBuf d_buf;
-
-        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GpuMat d_image(image);
+            cv::gpu::GpuMat d_lines;
+            cv::gpu::HoughLinesBuf d_buf;
+
             cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -155,17 +163,25 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
-
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_mask(mask);
-        cv::gpu::GpuMat d_pts;
-
-        d_detector(d_src, d_pts, d_mask);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
+
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_mask(mask);
+            cv::gpu::GpuMat d_pts;
+
             d_detector(d_src, d_pts, d_mask);
+
+            TEST_CYCLE()
+            {
+                d_detector(d_src, d_pts, d_mask);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -244,23 +260,31 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
-        cv::gpu::GpuMat d_nextPts;
-        cv::gpu::GpuMat d_status;
-
-        cv::gpu::PyrLKOpticalFlow d_pyrLK;
-        d_pyrLK.winSize = winSize;
-        d_pyrLK.maxLevel = maxLevel;
-        d_pyrLK.iters = criteria.maxCount;
-        d_pyrLK.useInitialFlow = false;
-
-        d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+            cv::gpu::GpuMat d_nextPts;
+            cv::gpu::GpuMat d_status;
+
+            cv::gpu::PyrLKOpticalFlow d_pyrLK;
+            d_pyrLK.winSize = winSize;
+            d_pyrLK.maxLevel = maxLevel;
+            d_pyrLK.iters = criteria.maxCount;
+            d_pyrLK.useInitialFlow = false;
+
             d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+
+            TEST_CYCLE()
+            {
+                d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -322,25 +346,33 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
-        cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
-
-        cv::gpu::FarnebackOpticalFlow d_farneback;
-        d_farneback.pyrScale = pyrScale;
-        d_farneback.numLevels = numLevels;
-        d_farneback.winSize = winSize;
-        d_farneback.numIters = numIters;
-        d_farneback.polyN = polyN;
-        d_farneback.polySigma = polySigma;
-        d_farneback.flags = flags;
-
-        d_farneback(d_src1, d_src2, d_u, d_v);
-
-        TEST_CYCLE_N(10)
+        try
         {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
+            cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
+
+            cv::gpu::FarnebackOpticalFlow d_farneback;
+            d_farneback.pyrScale = pyrScale;
+            d_farneback.numLevels = numLevels;
+            d_farneback.winSize = winSize;
+            d_farneback.numIters = numIters;
+            d_farneback.polyN = polyN;
+            d_farneback.polySigma = polySigma;
+            d_farneback.flags = flags;
+
             d_farneback(d_src1, d_src2, d_u, d_v);
+
+            TEST_CYCLE_N(10)
+            {
+                d_farneback(d_src1, d_src2, d_u, d_v);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -409,15 +441,23 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_velx, d_vely, buf;
-
-        cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
-        TEST_CYCLE_N(10)
+        try
         {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_velx, d_vely, buf;
+
             cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+            TEST_CYCLE_N(10)
+            {
+                cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -460,17 +500,25 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_velx, d_vely;
-
-        cv::gpu::FastOpticalFlowBM fastBM;
-
-        fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
-
-        TEST_CYCLE_N(10)
+        try
         {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_velx, d_vely;
+
+            cv::gpu::FastOpticalFlowBM fastBM;
+
             fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+
+            TEST_CYCLE_N(10)
+            {
+                fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
index 906024f64..3a086d9a8 100644
--- a/modules/gpu/perf/perf_calib3d.cpp
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -26,20 +26,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png",
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
-
-        cv::gpu::GpuMat d_imgLeft(imgLeft);
-        cv::gpu::GpuMat d_imgRight(imgRight);
-        cv::gpu::GpuMat d_dst;
-
-        d_bm(d_imgLeft, d_imgRight, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            d_bm(d_imgLeft, d_imgRight, d_dst);
-        }
+            cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GpuMat d_imgLeft(imgLeft);
+            cv::gpu::GpuMat d_imgRight(imgRight);
+            cv::gpu::GpuMat d_dst;
+
+            d_bm(d_imgLeft, d_imgRight, d_dst);
+
+            TEST_CYCLE()
+            {
+                d_bm(d_imgLeft, d_imgRight, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -75,20 +83,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::StereoBeliefPropagation d_bp(ndisp);
-
-        cv::gpu::GpuMat d_imgLeft(imgLeft);
-        cv::gpu::GpuMat d_imgRight(imgRight);
-        cv::gpu::GpuMat d_dst;
-
-        d_bp(d_imgLeft, d_imgRight, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            d_bp(d_imgLeft, d_imgRight, d_dst);
-        }
+            cv::gpu::StereoBeliefPropagation d_bp(ndisp);
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GpuMat d_imgLeft(imgLeft);
+            cv::gpu::GpuMat d_imgRight(imgRight);
+            cv::gpu::GpuMat d_dst;
+
+            d_bp(d_imgLeft, d_imgRight, d_dst);
+
+            TEST_CYCLE()
+            {
+                d_bp(d_imgLeft, d_imgRight, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -113,20 +129,28 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
-
-        cv::gpu::GpuMat d_imgLeft(imgLeft);
-        cv::gpu::GpuMat d_imgRight(imgRight);
-        cv::gpu::GpuMat d_dst;
-
-        d_csbp(d_imgLeft, d_imgRight, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            d_csbp(d_imgLeft, d_imgRight, d_dst);
-        }
+            cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GpuMat d_imgLeft(imgLeft);
+            cv::gpu::GpuMat d_imgRight(imgRight);
+            cv::gpu::GpuMat d_dst;
+
+            d_csbp(d_imgLeft, d_imgRight, d_dst);
+
+            TEST_CYCLE()
+            {
+                d_csbp(d_imgLeft, d_imgRight, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -149,20 +173,28 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::DisparityBilateralFilter d_filter(ndisp);
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_disp(disp);
-        cv::gpu::GpuMat d_dst;
-
-        d_filter(d_disp, d_img, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            d_filter(d_disp, d_img, d_dst);
-        }
+            cv::gpu::DisparityBilateralFilter d_filter(ndisp);
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_disp(disp);
+            cv::gpu::GpuMat d_dst;
+
+            d_filter(d_disp, d_img, d_dst);
+
+            TEST_CYCLE()
+            {
+                d_filter(d_disp, d_img, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -187,17 +219,25 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -221,17 +261,25 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -283,11 +331,19 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-
-        TEST_CYCLE()
+        try
         {
             cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -320,17 +376,25 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -360,17 +424,25 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::drawColorDisp(d_src, d_dst, 255);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::drawColorDisp(d_src, d_dst, 255);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::drawColorDisp(d_src, d_dst, 255);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::drawColorDisp(d_src, d_dst, 255);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index ad722fa3b..92d87c2e2 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -22,15 +22,23 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        std::vector<cv::gpu::GpuMat> d_src(channels);
-        for (int i = 0; i < channels; ++i)
-            d_src[i].upload(src[i]);
+        try
+        {
+            std::vector<cv::gpu::GpuMat> d_src(channels);
+            for (int i = 0; i < channels; ++i)
+                d_src[i].upload(src[i]);
 
-        cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-12);
+            GPU_SANITY_CHECK(d_dst, 1e-12);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -55,14 +63,22 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
 
-        std::vector<cv::gpu::GpuMat> d_dst;
+            std::vector<cv::gpu::GpuMat> d_dst;
 
-        TEST_CYCLE() cv::gpu::split(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::split(d_src, d_dst);
 
-        cv::gpu::GpuMat first = d_dst[0];
-        GPU_SANITY_CHECK(first, 1e-12);
+            cv::gpu::GpuMat first = d_dst[0];
+            GPU_SANITY_CHECK(first, 1e-12);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -90,13 +106,21 @@ PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEP
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -123,12 +147,20 @@ PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
+            TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -156,13 +188,21 @@ PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -189,12 +229,20 @@ PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
+            TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -222,13 +270,21 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -255,14 +311,22 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        cv::gpu::multiply(d_src, s, d_dst);
+            cv::gpu::multiply(d_src, s, d_dst);
 
-        TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
+            TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -290,13 +354,21 @@ PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -323,12 +395,20 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_M
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
+            TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -355,12 +435,20 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
+            TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -388,13 +476,21 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -421,12 +517,20 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
+            TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -451,12 +555,20 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else FAIL_NO_CPU();
 }
@@ -474,12 +586,20 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else FAIL_NO_CPU();
 }
@@ -497,12 +617,20 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -527,12 +655,20 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::log(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::log(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -557,12 +693,20 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -590,12 +734,20 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
+            TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -629,13 +781,21 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
+            TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -663,12 +823,20 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
+            TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -693,12 +861,20 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -726,13 +902,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -760,12 +944,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -793,13 +985,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -829,12 +1029,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -862,13 +1070,21 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -896,12 +1112,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
+            TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -931,12 +1155,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
+            TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -962,12 +1194,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
+            TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -991,13 +1231,21 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
+            TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1024,12 +1272,20 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
+            TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1057,13 +1313,21 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
+            TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1090,12 +1354,20 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
+            TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1131,13 +1403,21 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
+            TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1152,6 +1432,8 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 //////////////////////////////////////////////////////////////////////
 // GEMM
 
+#ifdef HAVE_CUBLAS
+
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
 #define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T)
 
@@ -1179,14 +1461,22 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_src3(src3);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_src3(src3);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
+            TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1200,6 +1490,8 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
     }
 }
 
+#endif // HAVE_CUBLAS
+
 //////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -1215,12 +1507,20 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
+            TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1259,12 +1559,20 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
+            TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1294,12 +1602,20 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1329,12 +1645,20 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1358,12 +1682,20 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
+            TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1390,12 +1722,20 @@ PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
+            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1418,13 +1758,21 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1433,7 +1781,6 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
         TEST_CYCLE() cv::magnitude(src1, src2, dst);
 
         CPU_SANITY_CHECK(dst, 1e-8);
-
     }
 }
 
@@ -1452,13 +1799,21 @@ PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
+            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
 
-        GPU_SANITY_CHECK(d_dst);
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1484,13 +1839,21 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
+            TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
 
-        GPU_SANITY_CHECK(d_dst, 1e-8);
+            GPU_SANITY_CHECK(d_dst, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1518,16 +1881,23 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_magnitude;
-        cv::gpu::GpuMat d_angle;
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_magnitude;
+            cv::gpu::GpuMat d_angle;
 
-        TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
-
-        GPU_SANITY_CHECK(d_magnitude, 1e-8);
-        GPU_SANITY_CHECK(d_angle, 1e-8);
+            TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
 
+            GPU_SANITY_CHECK(d_magnitude, 1e-8);
+            GPU_SANITY_CHECK(d_angle, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1557,15 +1927,23 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_magnitude(magnitude);
-        cv::gpu::GpuMat d_angle(angle);
-        cv::gpu::GpuMat d_x;
-        cv::gpu::GpuMat d_y;
+        try
+        {
+            cv::gpu::GpuMat d_magnitude(magnitude);
+            cv::gpu::GpuMat d_angle(angle);
+            cv::gpu::GpuMat d_x;
+            cv::gpu::GpuMat d_y;
 
-        TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
+            TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
 
-        GPU_SANITY_CHECK(d_x, 1e-8);
-        GPU_SANITY_CHECK(d_y, 1e-8);
+            GPU_SANITY_CHECK(d_x, 1e-8);
+            GPU_SANITY_CHECK(d_y, 1e-8);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1594,10 +1972,18 @@ PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
+            TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1628,10 +2014,18 @@ PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
+            TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1663,11 +2057,18 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-
-        TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
+        try
+        {
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
 
+            TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1698,10 +2099,18 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
+            TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1732,12 +2141,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
+            TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
 
-        SANITY_CHECK(dst, 1e-6);
+            SANITY_CHECK(dst, 1e-6);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1766,12 +2183,20 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
+            TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
 
-        SANITY_CHECK(dst, 1e-6);
+            SANITY_CHECK(dst, 1e-6);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1796,13 +2221,21 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
+            TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
 
-        SANITY_CHECK(minVal);
-        SANITY_CHECK(maxVal);
+            SANITY_CHECK(minVal);
+            SANITY_CHECK(maxVal);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1828,10 +2261,18 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_valbuf, d_locbuf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_valbuf, d_locbuf;
 
-        TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
+            TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1863,10 +2304,18 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_buf;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_buf;
 
-        TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
+            TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1908,12 +2357,20 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
+        try
+        {
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
+            TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
 
-        GPU_SANITY_CHECK(d_dst, 1);
+            GPU_SANITY_CHECK(d_dst, 1);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_denoising.cpp b/modules/gpu/perf/perf_denoising.cpp
index ed63177dd..0be16cbfd 100644
--- a/modules/gpu/perf/perf_denoising.cpp
+++ b/modules/gpu/perf/perf_denoising.cpp
@@ -30,19 +30,27 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
     cv::Mat src(size, type);
     fillRandom(src);
 
-     if (PERF_RUN_GPU())
+    if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -87,17 +95,25 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -130,18 +146,26 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::FastNonLocalMeansDenoising fnlmd;
-
-        fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
-
-        TEST_CYCLE()
+        try
         {
-            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        GPU_SANITY_CHECK(d_dst);
+            fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
+
+            TEST_CYCLE()
+            {
+                fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -181,18 +205,26 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::FastNonLocalMeansDenoising fnlmd;
-
-        fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-
-        TEST_CYCLE()
+        try
         {
-            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        GPU_SANITY_CHECK(d_dst);
+            fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
+
+            TEST_CYCLE()
+            {
+                fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -206,4 +238,4 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
         CPU_SANITY_CHECK(dst);
     }
-}
\ No newline at end of file
+}
diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp
index a93cef9b3..a0ecf0435 100644
--- a/modules/gpu/perf/perf_features2d.cpp
+++ b/modules/gpu/perf/perf_features2d.cpp
@@ -19,20 +19,28 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::SURF_GPU d_surf;
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_keypoints, d_descriptors;
-
-        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-
-        TEST_CYCLE()
+        try
         {
-            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-        }
+            cv::gpu::SURF_GPU d_surf;
 
-        GPU_SANITY_CHECK(d_descriptors, 1e-4);
-        GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_keypoints, d_descriptors;
+
+            d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+
+            TEST_CYCLE()
+            {
+                d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+            }
+
+            GPU_SANITY_CHECK(d_descriptors, 1e-4);
+            GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -64,19 +72,27 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::FAST_GPU d_fast(20);
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_keypoints;
-
-        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
-
-        TEST_CYCLE()
+        try
         {
-            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
-        }
+            cv::gpu::FAST_GPU d_fast(20);
 
-        GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_keypoints;
+
+            d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+
+            TEST_CYCLE()
+            {
+                d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+            }
+
+            GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -104,20 +120,28 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::ORB_GPU d_orb(4000);
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_keypoints, d_descriptors;
-
-        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-
-        TEST_CYCLE()
+        try
         {
-            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-        }
+            cv::gpu::ORB_GPU d_orb(4000);
 
-        GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
-        GPU_SANITY_CHECK(d_descriptors);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_keypoints, d_descriptors;
+
+            d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+
+            TEST_CYCLE()
+            {
+                d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+            }
+
+            GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
+            GPU_SANITY_CHECK(d_descriptors);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -161,21 +185,29 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-        cv::gpu::GpuMat d_query(query);
-        cv::gpu::GpuMat d_train(train);
-        cv::gpu::GpuMat d_trainIdx, d_distance;
-
-        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
-
-        TEST_CYCLE()
+        try
         {
-            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
-        }
+            cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-        GPU_SANITY_CHECK(d_trainIdx);
-        GPU_SANITY_CHECK(d_distance);
+            cv::gpu::GpuMat d_query(query);
+            cv::gpu::GpuMat d_train(train);
+            cv::gpu::GpuMat d_trainIdx, d_distance;
+
+            d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+
+            TEST_CYCLE()
+            {
+                d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+            }
+
+            GPU_SANITY_CHECK(d_trainIdx);
+            GPU_SANITY_CHECK(d_distance);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -220,21 +252,29 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-        cv::gpu::GpuMat d_query(query);
-        cv::gpu::GpuMat d_train(train);
-        cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
-
-        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
-
-        TEST_CYCLE()
+        try
         {
-            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
-        }
+            cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-        GPU_SANITY_CHECK(d_trainIdx);
-        GPU_SANITY_CHECK(d_distance);
+            cv::gpu::GpuMat d_query(query);
+            cv::gpu::GpuMat d_train(train);
+            cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
+
+            d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+
+            TEST_CYCLE()
+            {
+                d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+            }
+
+            GPU_SANITY_CHECK(d_trainIdx);
+            GPU_SANITY_CHECK(d_distance);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -273,21 +313,29 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-        cv::gpu::GpuMat d_query(query);
-        cv::gpu::GpuMat d_train(train);
-        cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
-
-        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
-
-        TEST_CYCLE()
+        try
         {
-            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
-        }
+            cv::gpu::BFMatcher_GPU d_matcher(normType);
 
-        GPU_SANITY_CHECK(d_trainIdx);
-        GPU_SANITY_CHECK(d_distance);
+            cv::gpu::GpuMat d_query(query);
+            cv::gpu::GpuMat d_train(train);
+            cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
+
+            d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+
+            TEST_CYCLE()
+            {
+                d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+            }
+
+            GPU_SANITY_CHECK(d_trainIdx);
+            GPU_SANITY_CHECK(d_distance);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 7faf93e97..47265fe11 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -23,17 +23,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
+
+            TEST_CYCLE()
+            {
+                cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -66,18 +74,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -109,18 +125,26 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -153,18 +177,26 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -197,17 +229,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -241,18 +281,26 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::erode(d_src, d_dst, ker, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::erode(d_src, d_dst, ker, d_buf);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::erode(d_src, d_dst, ker, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::erode(d_src, d_dst, ker, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -286,18 +334,26 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::dilate(d_src, d_dst, ker, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::dilate(d_src, d_dst, ker, d_buf);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::dilate(d_src, d_dst, ker, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::dilate(d_src, d_dst, ker, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -337,19 +393,27 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf1;
-        cv::gpu::GpuMat d_buf2;
-
-        cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf1;
+            cv::gpu::GpuMat d_buf2;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -385,17 +449,25 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::filter2D(d_src, d_dst, -1, kernel);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::filter2D(d_src, d_dst, -1, kernel);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::filter2D(d_src, d_dst, -1, kernel);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::filter2D(d_src, d_dst, -1, kernel);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index ee0968442..545b8df5a 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -80,19 +80,27 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_xmap(xmap);
-        cv::gpu::GpuMat d_ymap(ymap);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_xmap(xmap);
+            cv::gpu::GpuMat d_ymap(ymap);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -134,17 +142,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -185,17 +201,25 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -242,17 +266,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -298,17 +330,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -346,17 +386,25 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -393,17 +441,25 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -430,18 +486,26 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::integralBuffered(d_src, d_dst, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::integralBuffered(d_src, d_dst, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -468,17 +532,25 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::sqrIntegral(d_src, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::sqrIntegral(d_src, d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::sqrIntegral(d_src, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::sqrIntegral(d_src, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -499,18 +571,26 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_hist;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_hist;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_hist);
+            cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
+            }
+
+            GPU_SANITY_CHECK(d_hist);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -548,18 +628,26 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_hist[4];
-        cv::gpu::GpuMat d_buf, d_hist0;
-
-        cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_hist[4];
+            cv::gpu::GpuMat d_buf, d_hist0;
 
-        GPU_SANITY_CHECK(d_hist0);
+            cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
+            }
+
+            GPU_SANITY_CHECK(d_hist0);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -579,17 +667,25 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_hist;
-
-        cv::gpu::calcHist(d_src, d_hist);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::calcHist(d_src, d_hist);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_hist;
 
-        GPU_SANITY_CHECK(d_hist);
+            cv::gpu::calcHist(d_src, d_hist);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::calcHist(d_src, d_hist);
+            }
+
+            GPU_SANITY_CHECK(d_hist);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -609,19 +705,27 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_hist;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_hist;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_hist);
+            cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_hist);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -648,17 +752,25 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::columnSum(d_src, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::columnSum(d_src, d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::columnSum(d_src, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::columnSum(d_src, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -685,18 +797,26 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image(image);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::CannyBuf d_buf;
-
-        cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
-        }
+            cv::gpu::GpuMat d_image(image);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::CannyBuf d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -728,17 +848,25 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(rgba);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-        }
+            cv::gpu::GpuMat d_src(rgba);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -768,18 +896,26 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(rgba);
-        cv::gpu::GpuMat d_dstr;
-        cv::gpu::GpuMat d_dstsp;
-
-        cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-        }
+            cv::gpu::GpuMat d_src(rgba);
+            cv::gpu::GpuMat d_dstr;
+            cv::gpu::GpuMat d_dstsp;
 
-        GPU_SANITY_CHECK(d_dstr);
+            cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
+            }
+
+            GPU_SANITY_CHECK(d_dstr);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -804,16 +940,24 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(rgba);
-
-        cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-        }
+            cv::gpu::GpuMat d_src(rgba);
 
-        GPU_SANITY_CHECK(dst);
+            cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
+            }
+
+            GPU_SANITY_CHECK(dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -840,20 +984,28 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img1(img1);
-        cv::gpu::GpuMat d_img2(img2);
-        cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
-        cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-        }
+            cv::gpu::GpuMat d_img1(img1);
+            cv::gpu::GpuMat d_img2(img2);
+            cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
+            cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -882,23 +1034,31 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
-        d_image.upload(image);
-
-        cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
-        d_templ.upload(templ);
-
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::ConvolveBuf d_buf;
-
-        cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-        }
+            cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+            d_image.upload(image);
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+            d_templ.upload(templ);
+
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::ConvolveBuf d_buf;
+
+            cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -944,18 +1104,26 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image(image);
-        cv::gpu::GpuMat d_templ(templ);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-        }
+            cv::gpu::GpuMat d_image(image);
+            cv::gpu::GpuMat d_templ(templ);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -994,18 +1162,26 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_image(image);
-        cv::gpu::GpuMat d_templ(templ);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-        }
+            cv::gpu::GpuMat d_image(image);
+            cv::gpu::GpuMat d_templ(templ);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1044,18 +1220,26 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_a(a);
-        cv::gpu::GpuMat d_b(b);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-        }
+            cv::gpu::GpuMat d_a(a);
+            cv::gpu::GpuMat d_b(b);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1089,18 +1273,26 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src1(src1);
-        cv::gpu::GpuMat d_src2(src2);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-        }
+            cv::gpu::GpuMat d_src1(src1);
+            cv::gpu::GpuMat d_src2(src2);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1125,17 +1317,25 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::dft(d_src, d_dst, size, flag);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::dft(d_src, d_dst, size, flag);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::dft(d_src, d_dst, size, flag);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::dft(d_src, d_dst, size, flag);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1178,20 +1378,28 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_Dx;
-        cv::gpu::GpuMat d_Dy;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-        }
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_Dx;
+            cv::gpu::GpuMat d_Dy;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1231,20 +1439,28 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::GpuMat d_Dx;
-        cv::gpu::GpuMat d_Dy;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-        }
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_dst;
+            cv::gpu::GpuMat d_Dx;
+            cv::gpu::GpuMat d_Dy;
+            cv::gpu::GpuMat d_buf;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1274,18 +1490,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_map_x;
-        cv::gpu::GpuMat d_map_y;
-
-        cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-        }
+            cv::gpu::GpuMat d_map_x;
+            cv::gpu::GpuMat d_map_y;
 
-        GPU_SANITY_CHECK(d_map_x);
-        GPU_SANITY_CHECK(d_map_y);
+            cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
+            }
+
+            GPU_SANITY_CHECK(d_map_x);
+            GPU_SANITY_CHECK(d_map_y);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1305,18 +1529,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_map_x;
-        cv::gpu::GpuMat d_map_y;
-
-        cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-        }
+            cv::gpu::GpuMat d_map_x;
+            cv::gpu::GpuMat d_map_y;
 
-        GPU_SANITY_CHECK(d_map_x);
-        GPU_SANITY_CHECK(d_map_y);
+            cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+            }
+
+            GPU_SANITY_CHECK(d_map_x);
+            GPU_SANITY_CHECK(d_map_y);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1336,19 +1568,26 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_map_x;
-        cv::gpu::GpuMat d_map_y;
-
-        cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GpuMat d_map_x;
+            cv::gpu::GpuMat d_map_y;
+
             cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+            }
+
+            GPU_SANITY_CHECK(d_map_x);
+            GPU_SANITY_CHECK(d_map_y);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
-
-        GPU_SANITY_CHECK(d_map_x);
-        GPU_SANITY_CHECK(d_map_y);
-
     }
     else
     {
@@ -1379,17 +1618,25 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1416,17 +1663,25 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::pyrDown(d_src, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::pyrDown(d_src, d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::pyrDown(d_src, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::pyrDown(d_src, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1462,17 +1717,25 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::pyrUp(d_src, d_dst);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::pyrUp(d_src, d_dst);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::pyrUp(d_src, d_dst);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::pyrUp(d_src, d_dst);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1533,17 +1796,25 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1574,16 +1845,24 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-
-        cv::gpu::swapChannels(d_src, dstOrder);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::swapChannels(d_src, dstOrder);
-        }
+            cv::gpu::GpuMat d_src(src);
 
-        GPU_SANITY_CHECK(d_src);
+            cv::gpu::swapChannels(d_src, dstOrder);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::swapChannels(d_src, dstOrder);
+            }
+
+            GPU_SANITY_CHECK(d_src);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1613,18 +1892,26 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img1(img1);
-        cv::gpu::GpuMat d_img2(img2);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
-        }
+            cv::gpu::GpuMat d_img1(img1);
+            cv::gpu::GpuMat d_img2(img2);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1648,18 +1935,26 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-
-        cv::gpu::ImagePyramid d_pyr;
-
-        d_pyr.build(d_src, 5);
-
-        TEST_CYCLE()
+        try
         {
-            d_pyr.build(d_src, 5);
-        }
+            cv::gpu::GpuMat d_src(src);
 
-        GPU_SANITY_CHECK(d_src);
+            cv::gpu::ImagePyramid d_pyr;
+
+            d_pyr.build(d_src, 5);
+
+            TEST_CYCLE()
+            {
+                d_pyr.build(d_src, 5);
+            }
+
+            GPU_SANITY_CHECK(d_src);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1685,19 +1980,27 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        cv::gpu::ImagePyramid d_pyr(d_src, 3);
-
-        d_pyr.getLayer(d_dst, dstSize);
-
-        TEST_CYCLE()
+        try
         {
-            d_pyr.getLayer(d_dst, dstSize);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            cv::gpu::ImagePyramid d_pyr(d_src, 3);
+
+            d_pyr.getLayer(d_dst, dstSize);
+
+            TEST_CYCLE()
+            {
+                d_pyr.getLayer(d_dst, dstSize);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1762,22 +2065,30 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_lines;
-        cv::gpu::HoughLinesBuf d_buf;
-
-        cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_lines;
+            cv::gpu::HoughLinesBuf d_buf;
 
-        cv::Mat h_lines(d_lines);
-        cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
-        cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
-        std::sort(begin, end, Vec2fComparator());
-        SANITY_CHECK(h_lines);
+            cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
+            }
+
+            cv::Mat h_lines(d_lines);
+            cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
+            cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
+            std::sort(begin, end, Vec2fComparator());
+            SANITY_CHECK(h_lines);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1818,22 +2129,30 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_mask(mask);
-        cv::gpu::GpuMat d_lines;
-        cv::gpu::HoughLinesBuf d_buf;
-
-        cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-        }
+            cv::gpu::GpuMat d_mask(mask);
+            cv::gpu::GpuMat d_lines;
+            cv::gpu::HoughLinesBuf d_buf;
 
-        cv::Mat h_lines(d_lines);
-        cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
-        cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
-        std::sort(begin, end, Vec4iComparator());
-        SANITY_CHECK(h_lines);
+            cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+            }
+
+            cv::Mat h_lines(d_lines);
+            cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
+            cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
+            std::sort(begin, end, Vec4iComparator());
+            SANITY_CHECK(h_lines);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1883,22 +2202,30 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_circles;
-        cv::gpu::HoughCirclesBuf d_buf;
-
-        cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_circles;
+            cv::gpu::HoughCirclesBuf d_buf;
 
-        cv::Mat h_circles(d_circles);
-        cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
-        cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
-        std::sort(begin, end, Vec3fComparator());
-        SANITY_CHECK(h_circles);
+            cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+            }
+
+            cv::Mat h_circles(d_circles);
+            cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
+            cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
+            std::sort(begin, end, Vec3fComparator());
+            SANITY_CHECK(h_circles);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -1967,28 +2294,36 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_edges(edges);
-        cv::gpu::GpuMat d_dx(dx);
-        cv::gpu::GpuMat d_dy(dy);
-        cv::gpu::GpuMat d_position;
-
-        cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
-        if (method & cv::GHT_ROTATION)
+        try
         {
-            d_hough->set("maxAngle", 90.0);
-            d_hough->set("angleStep", 2.0);
-        }
+            cv::gpu::GpuMat d_edges(edges);
+            cv::gpu::GpuMat d_dx(dx);
+            cv::gpu::GpuMat d_dy(dy);
+            cv::gpu::GpuMat d_position;
 
-        d_hough->setTemplate(cv::gpu::GpuMat(templ));
+            cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
+            if (method & cv::GHT_ROTATION)
+            {
+                d_hough->set("maxAngle", 90.0);
+                d_hough->set("angleStep", 2.0);
+            }
 
-        d_hough->detect(d_edges, d_dx, d_dy, d_position);
+            d_hough->setTemplate(cv::gpu::GpuMat(templ));
 
-        TEST_CYCLE()
-        {
             d_hough->detect(d_edges, d_dx, d_dy, d_position);
-        }
 
-        GPU_SANITY_CHECK(d_position);
+            TEST_CYCLE()
+            {
+                d_hough->detect(d_edges, d_dx, d_dy, d_position);
+            }
+
+            GPU_SANITY_CHECK(d_position);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_labeling.cpp b/modules/gpu/perf/perf_labeling.cpp
index 3b10ba3be..0fb81aa13 100644
--- a/modules/gpu/perf/perf_labeling.cpp
+++ b/modules/gpu/perf/perf_labeling.cpp
@@ -108,22 +108,30 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat mask;
-        mask.create(image.rows, image.cols, CV_8UC1);
-
-        cv::gpu::GpuMat components;
-        components.create(image.rows, image.cols, CV_32SC1);
-
-        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
-
-        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::labelComponents(mask, components);
-        }
+            cv::gpu::GpuMat mask;
+            mask.create(image.rows, image.cols, CV_8UC1);
 
-        GPU_SANITY_CHECK(components);
+            cv::gpu::GpuMat components;
+            components.create(image.rows, image.cols, CV_32SC1);
+
+            cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+
+            ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+
+            TEST_CYCLE()
+            {
+                cv::gpu::labelComponents(mask, components);
+            }
+
+            GPU_SANITY_CHECK(components);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp
index b6d4a110f..97f6dd1d1 100644
--- a/modules/gpu/perf/perf_matop.cpp
+++ b/modules/gpu/perf/perf_matop.cpp
@@ -20,16 +20,24 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(size, type);
-
-        d_src.setTo(val);
-
-        TEST_CYCLE()
+        try
         {
-            d_src.setTo(val);
-        }
+            cv::gpu::GpuMat d_src(size, type);
 
-        GPU_SANITY_CHECK(d_src);
+            d_src.setTo(val);
+
+            TEST_CYCLE()
+            {
+                d_src.setTo(val);
+            }
+
+            GPU_SANITY_CHECK(d_src);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -67,17 +75,25 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_mask(mask);
-
-        d_src.setTo(val, d_mask);
-
-        TEST_CYCLE()
+        try
         {
-            d_src.setTo(val, d_mask);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_mask(mask);
 
-        GPU_SANITY_CHECK(d_src);
+            d_src.setTo(val, d_mask);
+
+            TEST_CYCLE()
+            {
+                d_src.setTo(val, d_mask);
+            }
+
+            GPU_SANITY_CHECK(d_src);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -111,18 +127,26 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_mask(mask);
-        cv::gpu::GpuMat d_dst;
-
-        d_src.copyTo(d_dst, d_mask);
-
-        TEST_CYCLE()
+        try
         {
-            d_src.copyTo(d_dst, d_mask);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_mask(mask);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            d_src.copyTo(d_dst, d_mask);
+
+            TEST_CYCLE()
+            {
+                d_src.copyTo(d_dst, d_mask);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -155,17 +179,25 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_src(src);
-        cv::gpu::GpuMat d_dst;
-
-        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
-
-        TEST_CYCLE()
+        try
         {
-            d_src.convertTo(d_dst, depth2, 0.5, 1.0);
-        }
+            cv::gpu::GpuMat d_src(src);
+            cv::gpu::GpuMat d_dst;
 
-        GPU_SANITY_CHECK(d_dst);
+            d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+
+            TEST_CYCLE()
+            {
+                d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+            }
+
+            GPU_SANITY_CHECK(d_dst);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 6d040ac02..4c74bba36 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -19,16 +19,24 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img(img);
-
-        cv::gpu::HOGDescriptor d_hog;
-        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-
-        d_hog.detectMultiScale(d_img, found_locations);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GpuMat d_img(img);
+
+            cv::gpu::HOGDescriptor d_hog;
+            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
             d_hog.detectMultiScale(d_img, found_locations);
+
+            TEST_CYCLE()
+            {
+                d_hog.detectMultiScale(d_img, found_locations);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -61,16 +69,24 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_img(img);
-
-        cv::gpu::HOGDescriptor d_hog;
-        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-
-        d_hog.detectMultiScale(d_img, found_locations);
-
-        TEST_CYCLE()
+        try
         {
+            cv::gpu::GpuMat d_img(img);
+
+            cv::gpu::HOGDescriptor d_hog;
+            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
             d_hog.detectMultiScale(d_img, found_locations);
+
+            TEST_CYCLE()
+            {
+                d_hog.detectMultiScale(d_img, found_locations);
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -103,20 +119,28 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::CascadeClassifier_GPU d_cascade;
-        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_objects_buffer;
-
-        d_cascade.detectMultiScale(d_img, d_objects_buffer);
-
-        TEST_CYCLE()
+        try
         {
-            d_cascade.detectMultiScale(d_img, d_objects_buffer);
-        }
+            cv::gpu::CascadeClassifier_GPU d_cascade;
+            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-        GPU_SANITY_CHECK(d_objects_buffer);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_objects_buffer;
+
+            d_cascade.detectMultiScale(d_img, d_objects_buffer);
+
+            TEST_CYCLE()
+            {
+                d_cascade.detectMultiScale(d_img, d_objects_buffer);
+            }
+
+            GPU_SANITY_CHECK(d_objects_buffer);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -147,20 +171,28 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::CascadeClassifier_GPU d_cascade;
-        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
-        cv::gpu::GpuMat d_img(img);
-        cv::gpu::GpuMat d_gpu_rects;
-
-        d_cascade.detectMultiScale(d_img, d_gpu_rects);
-
-        TEST_CYCLE()
+        try
         {
-            d_cascade.detectMultiScale(d_img, d_gpu_rects);
-        }
+            cv::gpu::CascadeClassifier_GPU d_cascade;
+            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
 
-        GPU_SANITY_CHECK(d_gpu_rects);
+            cv::gpu::GpuMat d_img(img);
+            cv::gpu::GpuMat d_gpu_rects;
+
+            d_cascade.detectMultiScale(d_img, d_gpu_rects);
+
+            TEST_CYCLE()
+            {
+                d_cascade.detectMultiScale(d_img, d_gpu_rects);
+            }
+
+            GPU_SANITY_CHECK(d_gpu_rects);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -180,4 +212,4 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     }
 }
 
-} // namespace
\ No newline at end of file
+} // namespace
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 9645beeaf..1d3ebe837 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -60,28 +60,36 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
 
 RUN_GPU(SCascadeTest, detect)
 {
-    cv::Mat cpu = readImage (GET_PARAM(1));
-    ASSERT_FALSE(cpu.empty());
-    cv::gpu::GpuMat colored(cpu);
-
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(1);
-
-    cascade.detect(colored, rois, objectBoxes);
-
-    TEST_CYCLE()
+    try
     {
-        cascade.detect(colored, rois, objectBoxes);
-    }
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
 
-    SANITY_CHECK(sortDetections(objectBoxes));
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(1);
+
+        cascade.detect(colored, rois, objectBoxes);
+
+        TEST_CYCLE()
+        {
+            cascade.detect(colored, rois, objectBoxes);
+        }
+
+        SANITY_CHECK(sortDetections(objectBoxes));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 NO_CPU(SCascadeTest, detect)
@@ -118,37 +126,45 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
 
 RUN_GPU(SCascadeTestRoi, detectInRoi)
 {
-    cv::Mat cpu = readImage (GET_PARAM(1));
-    ASSERT_FALSE(cpu.empty());
-    cv::gpu::GpuMat colored(cpu);
-
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(0);
-
-    int nroi = GET_PARAM(2);
-    cv::RNG rng;
-    for (int i = 0; i < nroi; ++i)
+    try
     {
-        cv::Rect r = getFromTable(rng(10));
-        cv::gpu::GpuMat sub(rois, r);
-        sub.setTo(1);
-    }
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
 
-    cascade.detect(colored, rois, objectBoxes);
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(0);
+
+        int nroi = GET_PARAM(2);
+        cv::RNG rng;
+        for (int i = 0; i < nroi; ++i)
+        {
+            cv::Rect r = getFromTable(rng(10));
+            cv::gpu::GpuMat sub(rois, r);
+            sub.setTo(1);
+        }
 
-    TEST_CYCLE()
-    {
         cascade.detect(colored, rois, objectBoxes);
-    }
 
-    SANITY_CHECK(sortDetections(objectBoxes));
+        TEST_CYCLE()
+        {
+            cascade.detect(colored, rois, objectBoxes);
+        }
+
+        SANITY_CHECK(sortDetections(objectBoxes));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 NO_CPU(SCascadeTestRoi, detectInRoi)
@@ -163,33 +179,41 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
 
 RUN_GPU(SCascadeTestRoi, detectEachRoi)
 {
-    cv::Mat cpu = readImage (GET_PARAM(1));
-    ASSERT_FALSE(cpu.empty());
-    cv::gpu::GpuMat colored(cpu);
-
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(0);
-
-    int idx = GET_PARAM(2);
-    cv::Rect r = getFromTable(idx);
-    cv::gpu::GpuMat sub(rois, r);
-    sub.setTo(1);
-
-    cascade.detect(colored, rois, objectBoxes);
-
-    TEST_CYCLE()
+    try
     {
-        cascade.detect(colored, rois, objectBoxes);
-    }
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
 
-    SANITY_CHECK(sortDetections(objectBoxes));
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(0);
+
+        int idx = GET_PARAM(2);
+        cv::Rect r = getFromTable(idx);
+        cv::gpu::GpuMat sub(rois, r);
+        sub.setTo(1);
+
+        cascade.detect(colored, rois, objectBoxes);
+
+        TEST_CYCLE()
+        {
+            cascade.detect(colored, rois, objectBoxes);
+        }
+
+        SANITY_CHECK(sortDetections(objectBoxes));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 NO_CPU(SCascadeTestRoi, detectEachRoi)
@@ -209,36 +233,44 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
 
 RUN_GPU(SCascadeTest, detectOnIntegral)
 {
-    cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-    ASSERT_TRUE(fsi.isOpened());
-
-    cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
-    for (int i = 0; i < 10; ++i)
+    try
     {
-        cv::Mat channel;
-        fsi[std::string("channel") + itoa(i)] >> channel;
-        cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-        gchannel.upload(channel);
-    }
+        cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+        ASSERT_TRUE(fsi.isOpened());
 
-    cv::gpu::SCascade cascade;
+        cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
+        for (int i = 0; i < 10; ++i)
+        {
+            cv::Mat channel;
+            fsi[std::string("channel") + itoa(i)] >> channel;
+            cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+            gchannel.upload(channel);
+        }
 
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+        cv::gpu::SCascade cascade;
 
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
 
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-    rois.setTo(1);
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cascade.detect(hogluv, rois, objectBoxes);
+        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+        rois.setTo(1);
 
-    TEST_CYCLE()
-    {
         cascade.detect(hogluv, rois, objectBoxes);
-    }
 
-    SANITY_CHECK(sortDetections(objectBoxes));
+        TEST_CYCLE()
+        {
+            cascade.detect(hogluv, rois, objectBoxes);
+        }
+
+        SANITY_CHECK(sortDetections(objectBoxes));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 NO_CPU(SCascadeTest, detectOnIntegral)
@@ -251,34 +283,42 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
 
 RUN_GPU(SCascadeTest, detectStream)
 {
-    cv::Mat cpu = readImage (GET_PARAM(1));
-    ASSERT_FALSE(cpu.empty());
-    cv::gpu::GpuMat colored(cpu);
-
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(1);
-
-    cv::gpu::Stream s;
-
-    cascade.detect(colored, rois, objectBoxes, s);
-
-    TEST_CYCLE()
+    try
     {
+        cv::Mat cpu = readImage (GET_PARAM(1));
+        ASSERT_FALSE(cpu.empty());
+        cv::gpu::GpuMat colored(cpu);
+
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(1);
+
+        cv::gpu::Stream s;
+
         cascade.detect(colored, rois, objectBoxes, s);
+
+        TEST_CYCLE()
+        {
+            cascade.detect(colored, rois, objectBoxes, s);
+        }
+
+    #ifdef HAVE_CUDA
+        cudaDeviceSynchronize();
+    #endif
+
+        SANITY_CHECK(sortDetections(objectBoxes));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-#ifdef HAVE_CUDA
-    cudaDeviceSynchronize();
-#endif
-
-    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detectStream)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 5afe0d15f..661050e0e 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -36,23 +36,31 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_u;
-        cv::gpu::GpuMat d_v;
-
-        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-        d_flow(d_frame0, d_frame1, d_u, d_v);
-
-        TEST_CYCLE()
+        try
         {
-            d_flow(d_frame0, d_frame1, d_u, d_v);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_u;
+            cv::gpu::GpuMat d_v;
 
-        GPU_SANITY_CHECK(d_u);
-        GPU_SANITY_CHECK(d_v);
+            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+            d_flow(d_frame0, d_frame1, d_u, d_v);
+
+            TEST_CYCLE()
+            {
+                d_flow(d_frame0, d_frame1, d_u, d_v);
+            }
+
+            GPU_SANITY_CHECK(d_u);
+            GPU_SANITY_CHECK(d_v);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -77,31 +85,39 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_fu, d_fv;
-        cv::gpu::GpuMat d_bu, d_bv;
-
-        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-        d_flow(d_frame0, d_frame1, d_fu, d_fv);
-        d_flow(d_frame1, d_frame0, d_bu, d_bv);
-
-        cv::gpu::GpuMat d_newFrame;
-        cv::gpu::GpuMat d_buf;
-
-        cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_fu, d_fv;
+            cv::gpu::GpuMat d_bu, d_bv;
 
-        GPU_SANITY_CHECK(d_fu);
-        GPU_SANITY_CHECK(d_fv);
-        GPU_SANITY_CHECK(d_bu);
-        GPU_SANITY_CHECK(d_bv);
+            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+            d_flow(d_frame0, d_frame1, d_fu, d_fv);
+            d_flow(d_frame1, d_frame0, d_bu, d_bv);
+
+            cv::gpu::GpuMat d_newFrame;
+            cv::gpu::GpuMat d_buf;
+
+            cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
+            }
+
+            GPU_SANITY_CHECK(d_fu);
+            GPU_SANITY_CHECK(d_fv);
+            GPU_SANITY_CHECK(d_bu);
+            GPU_SANITY_CHECK(d_bv);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -126,27 +142,35 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_u;
-        cv::gpu::GpuMat d_v;
-
-        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-        d_flow(d_frame0, d_frame1, d_u, d_v);
-
-        cv::gpu::GpuMat d_vertex, d_colors;
-
-        cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_u;
+            cv::gpu::GpuMat d_v;
 
-        GPU_SANITY_CHECK(d_vertex);
-        GPU_SANITY_CHECK(d_colors);
+            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+            d_flow(d_frame0, d_frame1, d_u, d_v);
+
+            cv::gpu::GpuMat d_vertex, d_colors;
+
+            cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
+            }
+
+            GPU_SANITY_CHECK(d_vertex);
+            GPU_SANITY_CHECK(d_colors);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -170,19 +194,27 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
-
-        cv::gpu::GpuMat d_image(image);
-        cv::gpu::GpuMat d_pts;
-
-        d_detector(d_image, d_pts);
-
-        TEST_CYCLE()
+        try
         {
-            d_detector(d_image, d_pts);
-        }
+            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
 
-        GPU_SANITY_CHECK(d_pts);
+            cv::gpu::GpuMat d_image(image);
+            cv::gpu::GpuMat d_pts;
+
+            d_detector(d_image, d_pts);
+
+            TEST_CYCLE()
+            {
+                d_detector(d_image, d_pts);
+            }
+
+            GPU_SANITY_CHECK(d_pts);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -238,26 +270,34 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
-
-        cv::gpu::PyrLKOpticalFlow d_pyrLK;
-        d_pyrLK.winSize = cv::Size(winSize, winSize);
-        d_pyrLK.maxLevel = levels - 1;
-        d_pyrLK.iters = iters;
-
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_nextPts;
-        cv::gpu::GpuMat d_status;
-
-        d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-
-        TEST_CYCLE()
+        try
         {
-            d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-        }
+            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
 
-        GPU_SANITY_CHECK(d_status);
+            cv::gpu::PyrLKOpticalFlow d_pyrLK;
+            d_pyrLK.winSize = cv::Size(winSize, winSize);
+            d_pyrLK.maxLevel = levels - 1;
+            d_pyrLK.iters = iters;
+
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_nextPts;
+            cv::gpu::GpuMat d_status;
+
+            d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
+
+            TEST_CYCLE()
+            {
+                d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
+            }
+
+            GPU_SANITY_CHECK(d_status);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -305,25 +345,33 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_u;
-        cv::gpu::GpuMat d_v;
-
-        cv::gpu::PyrLKOpticalFlow d_pyrLK;
-        d_pyrLK.winSize = cv::Size(winSize, winSize);
-        d_pyrLK.maxLevel = levels - 1;
-        d_pyrLK.iters = iters;
-
-        d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
-
-        TEST_CYCLE()
+        try
         {
-            d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_u;
+            cv::gpu::GpuMat d_v;
 
-        GPU_SANITY_CHECK(d_u);
-        GPU_SANITY_CHECK(d_v);
+            cv::gpu::PyrLKOpticalFlow d_pyrLK;
+            d_pyrLK.winSize = cv::Size(winSize, winSize);
+            d_pyrLK.maxLevel = levels - 1;
+            d_pyrLK.iters = iters;
+
+            d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
+
+            TEST_CYCLE()
+            {
+                d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
+            }
+
+            GPU_SANITY_CHECK(d_u);
+            GPU_SANITY_CHECK(d_v);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -355,29 +403,37 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_u;
-        cv::gpu::GpuMat d_v;
-
-        cv::gpu::FarnebackOpticalFlow d_farneback;
-        d_farneback.numLevels = numLevels;
-        d_farneback.pyrScale = pyrScale;
-        d_farneback.winSize = winSize;
-        d_farneback.numIters = numIters;
-        d_farneback.polyN = polyN;
-        d_farneback.polySigma = polySigma;
-        d_farneback.flags = flags;
-
-        d_farneback(d_frame0, d_frame1, d_u, d_v);
-
-        TEST_CYCLE()
+        try
         {
-            d_farneback(d_frame0, d_frame1, d_u, d_v);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_u;
+            cv::gpu::GpuMat d_v;
 
-        GPU_SANITY_CHECK(d_u);
-        GPU_SANITY_CHECK(d_v);
+            cv::gpu::FarnebackOpticalFlow d_farneback;
+            d_farneback.numLevels = numLevels;
+            d_farneback.pyrScale = pyrScale;
+            d_farneback.winSize = winSize;
+            d_farneback.numIters = numIters;
+            d_farneback.polyN = polyN;
+            d_farneback.polySigma = polySigma;
+            d_farneback.flags = flags;
+
+            d_farneback(d_frame0, d_frame1, d_u, d_v);
+
+            TEST_CYCLE()
+            {
+                d_farneback(d_frame0, d_frame1, d_u, d_v);
+            }
+
+            GPU_SANITY_CHECK(d_u);
+            GPU_SANITY_CHECK(d_v);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -410,22 +466,30 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_flowx;
-        cv::gpu::GpuMat d_flowy;
-
-        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-
-        d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
-
-        TEST_CYCLE()
+        try
         {
-            d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_flowx;
+            cv::gpu::GpuMat d_flowy;
 
-        GPU_SANITY_CHECK(d_flowx);
-        GPU_SANITY_CHECK(d_flowy);
+            cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+
+            d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+
+            TEST_CYCLE()
+            {
+                d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+            }
+
+            GPU_SANITY_CHECK(d_flowx);
+            GPU_SANITY_CHECK(d_flowy);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -482,19 +546,27 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_velx, d_vely, buf;
-
-        cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
-        TEST_CYCLE()
+        try
         {
-            cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_velx, d_vely, buf;
 
-        GPU_SANITY_CHECK(d_velx);
-        GPU_SANITY_CHECK(d_vely);
+            cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+            TEST_CYCLE()
+            {
+                cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+            }
+
+            GPU_SANITY_CHECK(d_velx);
+            GPU_SANITY_CHECK(d_vely);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -529,21 +601,29 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame0(frame0);
-        cv::gpu::GpuMat d_frame1(frame1);
-        cv::gpu::GpuMat d_velx, d_vely;
-
-        cv::gpu::FastOpticalFlowBM fastBM;
-
-        fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
-
-        TEST_CYCLE()
+        try
         {
-            fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
-        }
+            cv::gpu::GpuMat d_frame0(frame0);
+            cv::gpu::GpuMat d_frame1(frame1);
+            cv::gpu::GpuMat d_velx, d_vely;
 
-        GPU_SANITY_CHECK(d_velx);
-        GPU_SANITY_CHECK(d_vely);
+            cv::gpu::FastOpticalFlowBM fastBM;
+
+            fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+
+            TEST_CYCLE()
+            {
+                fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+            }
+
+            GPU_SANITY_CHECK(d_velx);
+            GPU_SANITY_CHECK(d_vely);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -581,21 +661,29 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi",
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame(frame);
-
-        cv::gpu::FGDStatModel d_model(4);
-        d_model.create(d_frame);
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::GpuMat d_frame(frame);
 
-            d_frame.upload(frame);
+            cv::gpu::FGDStatModel d_model(4);
+            d_model.create(d_frame);
 
-            startTimer(); next();
-            d_model.update(d_frame);
-            stopTimer();
+            for (int i = 0; i < 10; ++i)
+            {
+                cap >> frame;
+                ASSERT_FALSE(frame.empty());
+
+                d_frame.upload(frame);
+
+                startTimer(); next();
+                d_model.update(d_frame);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -649,32 +737,40 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::MOG_GPU d_mog;
-        cv::gpu::GpuMat d_foreground;
-
-        d_mog(d_frame, d_foreground, learningRate);
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::GpuMat d_frame(frame);
+            cv::gpu::MOG_GPU d_mog;
+            cv::gpu::GpuMat d_foreground;
 
-            if (cn != 3)
-            {
-                cv::Mat temp;
-                if (cn == 1)
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                else
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                cv::swap(temp, frame);
-            }
-
-            d_frame.upload(frame);
-
-            startTimer(); next();
             d_mog(d_frame, d_foreground, learningRate);
-            stopTimer();
+
+            for (int i = 0; i < 10; ++i)
+            {
+                cap >> frame;
+                ASSERT_FALSE(frame.empty());
+
+                if (cn != 3)
+                {
+                    cv::Mat temp;
+                    if (cn == 1)
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                    else
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                    cv::swap(temp, frame);
+                }
+
+                d_frame.upload(frame);
+
+                startTimer(); next();
+                d_mog(d_frame, d_foreground, learningRate);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -737,32 +833,40 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::MOG2_GPU d_mog2;
-        cv::gpu::GpuMat d_foreground;
-
-        d_mog2(d_frame, d_foreground);
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::GpuMat d_frame(frame);
+            cv::gpu::MOG2_GPU d_mog2;
+            cv::gpu::GpuMat d_foreground;
 
-            if (cn != 3)
-            {
-                cv::Mat temp;
-                if (cn == 1)
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                else
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                cv::swap(temp, frame);
-            }
-
-            d_frame.upload(frame);
-
-            startTimer(); next();
             d_mog2(d_frame, d_foreground);
-            stopTimer();
+
+            for (int i = 0; i < 10; ++i)
+            {
+                cap >> frame;
+                ASSERT_FALSE(frame.empty());
+
+                if (cn != 3)
+                {
+                    cv::Mat temp;
+                    if (cn == 1)
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                    else
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                    cv::swap(temp, frame);
+                }
+
+                d_frame.upload(frame);
+
+                startTimer(); next();
+                d_mog2(d_frame, d_foreground);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -810,39 +914,47 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame;
-        cv::gpu::MOG2_GPU d_mog2;
-        cv::gpu::GpuMat d_foreground;
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::GpuMat d_frame;
+            cv::gpu::MOG2_GPU d_mog2;
+            cv::gpu::GpuMat d_foreground;
 
-            if (cn != 3)
+            for (int i = 0; i < 10; ++i)
             {
-                cv::Mat temp;
-                if (cn == 1)
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                else
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                cv::swap(temp, frame);
+                cap >> frame;
+                ASSERT_FALSE(frame.empty());
+
+                if (cn != 3)
+                {
+                    cv::Mat temp;
+                    if (cn == 1)
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                    else
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                    cv::swap(temp, frame);
+                }
+
+                d_frame.upload(frame);
+
+                d_mog2(d_frame, d_foreground);
             }
 
-            d_frame.upload(frame);
-
-            d_mog2(d_frame, d_foreground);
-        }
-
-        cv::gpu::GpuMat d_background;
-        d_mog2.getBackgroundImage(d_background);
-
-        TEST_CYCLE()
-        {
+            cv::gpu::GpuMat d_background;
             d_mog2.getBackgroundImage(d_background);
-        }
 
-        GPU_SANITY_CHECK(d_background);
+            TEST_CYCLE()
+            {
+                d_mog2.getBackgroundImage(d_background);
+            }
+
+            GPU_SANITY_CHECK(d_background);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
@@ -907,32 +1019,40 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::VIBE_GPU d_vibe;
-        cv::gpu::GpuMat d_foreground;
-
-        d_vibe(d_frame, d_foreground);
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::GpuMat d_frame(frame);
+            cv::gpu::VIBE_GPU d_vibe;
+            cv::gpu::GpuMat d_foreground;
 
-            if (cn != 3)
-            {
-                cv::Mat temp;
-                if (cn == 1)
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                else
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                cv::swap(temp, frame);
-            }
-
-            d_frame.upload(frame);
-
-            startTimer(); next();
             d_vibe(d_frame, d_foreground);
-            stopTimer();
+
+            for (int i = 0; i < 10; ++i)
+            {
+                cap >> frame;
+                ASSERT_FALSE(frame.empty());
+
+                if (cn != 3)
+                {
+                    cv::Mat temp;
+                    if (cn == 1)
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                    else
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                    cv::swap(temp, frame);
+                }
+
+                d_frame.upload(frame);
+
+                startTimer(); next();
+                d_vibe(d_frame, d_foreground);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -972,39 +1092,47 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::GpuMat d_fgmask;
-
-        cv::gpu::GMG_GPU d_gmg;
-        d_gmg.maxFeatures = maxFeatures;
-
-        d_gmg(d_frame, d_fgmask);
-
-        for (int i = 0; i < 150; ++i)
+        try
         {
-            cap >> frame;
-            if (frame.empty())
-            {
-                cap.release();
-                cap.open(inputFile);
-                cap >> frame;
-            }
+            cv::gpu::GpuMat d_frame(frame);
+            cv::gpu::GpuMat d_fgmask;
 
-            if (cn != 3)
-            {
-                cv::Mat temp;
-                if (cn == 1)
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                else
-                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                cv::swap(temp, frame);
-            }
+            cv::gpu::GMG_GPU d_gmg;
+            d_gmg.maxFeatures = maxFeatures;
 
-            d_frame.upload(frame);
-
-            startTimer(); next();
             d_gmg(d_frame, d_fgmask);
-            stopTimer();
+
+            for (int i = 0; i < 150; ++i)
+            {
+                cap >> frame;
+                if (frame.empty())
+                {
+                    cap.release();
+                    cap.open(inputFile);
+                    cap >> frame;
+                }
+
+                if (cn != 3)
+                {
+                    cv::Mat temp;
+                    if (cn == 1)
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                    else
+                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                    cv::swap(temp, frame);
+                }
+
+                d_frame.upload(frame);
+
+                startTimer(); next();
+                d_gmg(d_frame, d_fgmask);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -1066,23 +1194,31 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::VideoWriter_GPU d_writer;
-
-        cv::gpu::GpuMat d_frame;
-
-        for (int i = 0; i < 10; ++i)
+        try
         {
-            reader >> frame;
-            ASSERT_FALSE(frame.empty());
+            cv::gpu::VideoWriter_GPU d_writer;
 
-            d_frame.upload(frame);
+            cv::gpu::GpuMat d_frame;
 
-            if (!d_writer.isOpened())
-                d_writer.open(outputFile, frame.size(), FPS);
+            for (int i = 0; i < 10; ++i)
+            {
+                reader >> frame;
+                ASSERT_FALSE(frame.empty());
 
-            startTimer(); next();
-            d_writer.write(d_frame);
-            stopTimer();
+                d_frame.upload(frame);
+
+                if (!d_writer.isOpened())
+                    d_writer.open(outputFile, frame.size(), FPS);
+
+                startTimer(); next();
+                d_writer.write(d_frame);
+                stopTimer();
+            }
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
         }
     }
     else
@@ -1115,19 +1251,27 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        cv::gpu::VideoReader_GPU d_reader(inputFile);
-        ASSERT_TRUE( d_reader.isOpened() );
-
-        cv::gpu::GpuMat d_frame;
-
-        d_reader.read(d_frame);
-
-        TEST_CYCLE_N(10)
+        try
         {
-            d_reader.read(d_frame);
-        }
+            cv::gpu::VideoReader_GPU d_reader(inputFile);
+            ASSERT_TRUE( d_reader.isOpened() );
 
-        GPU_SANITY_CHECK(d_frame);
+            cv::gpu::GpuMat d_frame;
+
+            d_reader.read(d_frame);
+
+            TEST_CYCLE_N(10)
+            {
+                d_reader.read(d_frame);
+            }
+
+            GPU_SANITY_CHECK(d_frame);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
     }
     else
     {
diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp
index 7873563ce..43c92ce1e 100644
--- a/modules/gpu/test/nvidia/main_nvidia.cpp
+++ b/modules/gpu/test/nvidia/main_nvidia.cpp
@@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg)
     (void)msg;
 }
 
+}
+
 bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path.c_str();
@@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
     return testListerII.invoke();
 }
 
-}
-
 bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path;
@@ -439,4 +439,4 @@ bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel out
     return testListerVisualize.invoke();
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp
index a294a3df9..4a53c6093 100644
--- a/modules/gpu/test/test_calib3d.cpp
+++ b/modules/gpu/test/test_calib3d.cpp
@@ -62,20 +62,28 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBM, Regression)
 {
-    cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-    cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    try
+    {
+        cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+        cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
+        cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(left_image.empty());
-    ASSERT_FALSE(right_image.empty());
-    ASSERT_FALSE(disp_gold.empty());
+        ASSERT_FALSE(left_image.empty());
+        ASSERT_FALSE(right_image.empty());
+        ASSERT_FALSE(disp_gold.empty());
 
-    cv::gpu::StereoBM_GPU bm(0, 128, 19);
-    cv::gpu::GpuMat disp;
+        cv::gpu::StereoBM_GPU bm(0, 128, 19);
+        cv::gpu::GpuMat disp;
 
-    bm(loadMat(left_image), loadMat(right_image), disp);
+        bm(loadMat(left_image), loadMat(right_image), disp);
 
-    EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
+        EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@@ -97,23 +105,31 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBeliefPropagation, Regression)
 {
-    cv::Mat left_image  = readImage("stereobp/aloe-L.png");
-    cv::Mat right_image = readImage("stereobp/aloe-R.png");
-    cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    try
+    {
+        cv::Mat left_image  = readImage("stereobp/aloe-L.png");
+        cv::Mat right_image = readImage("stereobp/aloe-R.png");
+        cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(left_image.empty());
-    ASSERT_FALSE(right_image.empty());
-    ASSERT_FALSE(disp_gold.empty());
+        ASSERT_FALSE(left_image.empty());
+        ASSERT_FALSE(right_image.empty());
+        ASSERT_FALSE(disp_gold.empty());
 
-    cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
-    cv::gpu::GpuMat disp;
+        cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+        cv::gpu::GpuMat disp;
 
-    bp(loadMat(left_image), loadMat(right_image), disp);
+        bp(loadMat(left_image), loadMat(right_image), disp);
 
-    cv::Mat h_disp(disp);
-    h_disp.convertTo(h_disp, disp_gold.depth());
+        cv::Mat h_disp(disp);
+        h_disp.convertTo(h_disp, disp_gold.depth());
 
-    EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
+        EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@@ -135,29 +151,37 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoConstantSpaceBP, Regression)
 {
-    cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
-    cv::Mat right_image = readImage("csstereobp/aloe-R.png");
+    try
+    {
+        cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
+        cv::Mat right_image = readImage("csstereobp/aloe-R.png");
 
-    cv::Mat disp_gold;
+        cv::Mat disp_gold;
 
-    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-        disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-    else
-        disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+        else
+            disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
 
-    ASSERT_FALSE(left_image.empty());
-    ASSERT_FALSE(right_image.empty());
-    ASSERT_FALSE(disp_gold.empty());
+        ASSERT_FALSE(left_image.empty());
+        ASSERT_FALSE(right_image.empty());
+        ASSERT_FALSE(disp_gold.empty());
 
-    cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
-    cv::gpu::GpuMat disp;
+        cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
+        cv::gpu::GpuMat disp;
 
-    csbp(loadMat(left_image), loadMat(right_image), disp);
+        csbp(loadMat(left_image), loadMat(right_image), disp);
 
-    cv::Mat h_disp(disp);
-    h_disp.convertTo(h_disp, disp_gold.depth());
+        cv::Mat h_disp(disp);
+        h_disp.convertTo(h_disp, disp_gold.depth());
 
-    EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
+        EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@@ -179,32 +203,40 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(TransformPoints, Accuracy)
 {
-    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-
-    cv::gpu::GpuMat dst;
-    cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
-
-    ASSERT_EQ(src.size(), dst.size());
-    ASSERT_EQ(src.type(), dst.type());
-
-    cv::Mat h_dst(dst);
-
-    cv::Mat rot;
-    cv::Rodrigues(rvec, rot);
-
-    for (int i = 0; i < h_dst.cols; ++i)
+    try
     {
-        cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
+        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
 
-        cv::Point3f p = src.at<cv::Point3f>(0, i);
-        cv::Point3f res_gold(
-                rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
-                rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
-                rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
+        cv::gpu::GpuMat dst;
+        cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
 
-        ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
+        ASSERT_EQ(src.size(), dst.size());
+        ASSERT_EQ(src.type(), dst.type());
+
+        cv::Mat h_dst(dst);
+
+        cv::Mat rot;
+        cv::Rodrigues(rvec, rot);
+
+        for (int i = 0; i < h_dst.cols; ++i)
+        {
+            cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
+
+            cv::Point3f p = src.at<cv::Point3f>(0, i);
+            cv::Point3f res_gold(
+                    rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
+                    rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
+                    rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
+
+            ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -227,34 +259,42 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(ProjectPoints, Accuracy)
 {
-    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-    camera_mat.at<float>(0, 1) = 0.f;
-    camera_mat.at<float>(1, 0) = 0.f;
-    camera_mat.at<float>(2, 0) = 0.f;
-    camera_mat.at<float>(2, 1) = 0.f;
-
-    cv::gpu::GpuMat dst;
-    cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
-
-    ASSERT_EQ(1, dst.rows);
-    ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
-
-    std::vector<cv::Point2f> dst_gold;
-    cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
-
-    ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
-
-    cv::Mat h_dst(dst);
-
-    for (size_t i = 0; i < dst_gold.size(); ++i)
+    try
     {
-        cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
-        cv::Point2f res_gold = dst_gold[i];
+        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+        camera_mat.at<float>(0, 1) = 0.f;
+        camera_mat.at<float>(1, 0) = 0.f;
+        camera_mat.at<float>(2, 0) = 0.f;
+        camera_mat.at<float>(2, 1) = 0.f;
 
-        ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
+        cv::gpu::GpuMat dst;
+        cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
+
+        ASSERT_EQ(1, dst.rows);
+        ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
+
+        std::vector<cv::Point2f> dst_gold;
+        cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
+
+        ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
+
+        cv::Mat h_dst(dst);
+
+        for (size_t i = 0; i < dst_gold.size(); ++i)
+        {
+            cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
+            cv::Point2f res_gold = dst_gold[i];
+
+            ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -277,28 +317,36 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(SolvePnPRansac, Accuracy)
 {
-    cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
-    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-    camera_mat.at<float>(0, 1) = 0.f;
-    camera_mat.at<float>(1, 0) = 0.f;
-    camera_mat.at<float>(2, 0) = 0.f;
-    camera_mat.at<float>(2, 1) = 0.f;
+    try
+    {
+        cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
+        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+        camera_mat.at<float>(0, 1) = 0.f;
+        camera_mat.at<float>(1, 0) = 0.f;
+        camera_mat.at<float>(2, 0) = 0.f;
+        camera_mat.at<float>(2, 1) = 0.f;
 
-    std::vector<cv::Point2f> image_vec;
-    cv::Mat rvec_gold;
-    cv::Mat tvec_gold;
-    rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-    tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-    cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
+        std::vector<cv::Point2f> image_vec;
+        cv::Mat rvec_gold;
+        cv::Mat tvec_gold;
+        rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
 
-    cv::Mat rvec, tvec;
-    std::vector<int> inliers;
-    cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
-                            camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
-                            rvec, tvec, false, 200, 2.f, 100, &inliers);
+        cv::Mat rvec, tvec;
+        std::vector<int> inliers;
+        cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
+                                camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
+                                rvec, tvec, false, 200, 2.f, 100, &inliers);
 
-    ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
-    ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
+        ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
+        ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
@@ -326,16 +374,24 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
 
 TEST_P(ReprojectImageTo3D, Accuracy)
 {
-    cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
-    cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
+    try
+    {
+        cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
+        cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
+        cv::gpu::GpuMat dst;
+        cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
 
-    cv::Mat dst_gold;
-    cv::reprojectImageTo3D(disp, dst_gold, Q, false);
+        cv::Mat dst_gold;
+        cv::reprojectImageTo3D(disp, dst_gold, Q, false);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp
index 2510f564d..e350ee965 100644
--- a/modules/gpu/test/test_color.cpp
+++ b/modules/gpu/test/test_color.cpp
@@ -72,165 +72,261 @@ PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CvtColor, BGR2RGB)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2RGBA)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2BGRA)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2RGB)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2RGBA)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2GRAY)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2GRAY)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, GRAY2BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, GRAY2BGRA)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2GRAY)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2GRAY)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2BGR565)
@@ -238,15 +334,23 @@ TEST_P(CvtColor, BGR2BGR565)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2BGR565)
@@ -254,15 +358,23 @@ TEST_P(CvtColor, RGB2BGR565)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5652BGR)
@@ -270,16 +382,24 @@ TEST_P(CvtColor, BGR5652BGR)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5652RGB)
@@ -287,16 +407,24 @@ TEST_P(CvtColor, BGR5652RGB)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2BGR565)
@@ -304,16 +432,24 @@ TEST_P(CvtColor, BGRA2BGR565)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2BGR565)
@@ -321,16 +457,24 @@ TEST_P(CvtColor, RGBA2BGR565)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5652BGRA)
@@ -338,16 +482,24 @@ TEST_P(CvtColor, BGR5652BGRA)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5652RGBA)
@@ -355,16 +507,24 @@ TEST_P(CvtColor, BGR5652RGBA)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, GRAY2BGR565)
@@ -372,16 +532,24 @@ TEST_P(CvtColor, GRAY2BGR565)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5652GRAY)
@@ -389,16 +557,24 @@ TEST_P(CvtColor, BGR5652GRAY)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2BGR555)
@@ -406,15 +582,23 @@ TEST_P(CvtColor, BGR2BGR555)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2BGR555)
@@ -422,15 +606,23 @@ TEST_P(CvtColor, RGB2BGR555)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5552BGR)
@@ -438,16 +630,24 @@ TEST_P(CvtColor, BGR5552BGR)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5552RGB)
@@ -455,16 +655,24 @@ TEST_P(CvtColor, BGR5552RGB)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2BGR555)
@@ -472,16 +680,24 @@ TEST_P(CvtColor, BGRA2BGR555)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2BGR555)
@@ -489,16 +705,24 @@ TEST_P(CvtColor, RGBA2BGR555)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5552BGRA)
@@ -506,16 +730,24 @@ TEST_P(CvtColor, BGR5552BGRA)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5552RGBA)
@@ -523,16 +755,24 @@ TEST_P(CvtColor, BGR5552RGBA)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, GRAY2BGR555)
@@ -540,16 +780,24 @@ TEST_P(CvtColor, GRAY2BGR555)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR5552GRAY)
@@ -557,286 +805,422 @@ TEST_P(CvtColor, BGR5552GRAY)
     if (depth != CV_8U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2XYZ)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2XYZ)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2XYZ4)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGRA2XYZ4)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, XYZ2BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, XYZ2RGB)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, XYZ42BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, XYZ42BGRA)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2YCrCb)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2YCrCb)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2YCrCb4)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2YCrCb4)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YCrCb2BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YCrCb2RGB)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YCrCb42RGB)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YCrCb42RGBA)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2HSV)
@@ -844,15 +1228,23 @@ TEST_P(CvtColor, BGR2HSV)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HSV)
@@ -860,15 +1252,23 @@ TEST_P(CvtColor, RGB2HSV)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HSV4)
@@ -876,23 +1276,31 @@ TEST_P(CvtColor, RGB2HSV4)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2HSV4)
@@ -900,24 +1308,32 @@ TEST_P(CvtColor, RGBA2HSV4)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2HLS)
@@ -925,15 +1341,23 @@ TEST_P(CvtColor, BGR2HLS)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HLS)
@@ -941,15 +1365,23 @@ TEST_P(CvtColor, RGB2HLS)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HLS4)
@@ -957,23 +1389,31 @@ TEST_P(CvtColor, RGB2HLS4)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2HLS4)
@@ -981,24 +1421,32 @@ TEST_P(CvtColor, RGBA2HLS4)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV2BGR)
@@ -1006,16 +1454,24 @@ TEST_P(CvtColor, HSV2BGR)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV2RGB)
@@ -1023,16 +1479,24 @@ TEST_P(CvtColor, HSV2RGB)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV42BGR)
@@ -1040,21 +1504,29 @@ TEST_P(CvtColor, HSV42BGR)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV42BGRA)
@@ -1062,21 +1534,29 @@ TEST_P(CvtColor, HSV42BGRA)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS2BGR)
@@ -1084,16 +1564,24 @@ TEST_P(CvtColor, HLS2BGR)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS2RGB)
@@ -1101,16 +1589,24 @@ TEST_P(CvtColor, HLS2RGB)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS42RGB)
@@ -1118,21 +1614,29 @@ TEST_P(CvtColor, HLS42RGB)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS42RGBA)
@@ -1140,22 +1644,30 @@ TEST_P(CvtColor, HLS42RGBA)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2HSV_FULL)
@@ -1163,15 +1675,23 @@ TEST_P(CvtColor, BGR2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HSV_FULL)
@@ -1179,15 +1699,23 @@ TEST_P(CvtColor, RGB2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HSV4_FULL)
@@ -1195,23 +1723,31 @@ TEST_P(CvtColor, RGB2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2HSV4_FULL)
@@ -1219,24 +1755,32 @@ TEST_P(CvtColor, RGBA2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2HLS_FULL)
@@ -1244,15 +1788,23 @@ TEST_P(CvtColor, BGR2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HLS_FULL)
@@ -1260,15 +1812,23 @@ TEST_P(CvtColor, RGB2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2HLS4_FULL)
@@ -1276,23 +1836,31 @@ TEST_P(CvtColor, RGB2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2HLS4_FULL)
@@ -1300,24 +1868,32 @@ TEST_P(CvtColor, RGBA2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV2BGR_FULL)
@@ -1325,16 +1901,24 @@ TEST_P(CvtColor, HSV2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV2RGB_FULL)
@@ -1342,16 +1926,24 @@ TEST_P(CvtColor, HSV2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV42RGB_FULL)
@@ -1359,21 +1951,29 @@ TEST_P(CvtColor, HSV42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HSV42RGBA_FULL)
@@ -1381,21 +1981,29 @@ TEST_P(CvtColor, HSV42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS2BGR_FULL)
@@ -1403,16 +2011,24 @@ TEST_P(CvtColor, HLS2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS2RGB_FULL)
@@ -1420,16 +2036,24 @@ TEST_P(CvtColor, HLS2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS42RGB_FULL)
@@ -1437,21 +2061,29 @@ TEST_P(CvtColor, HLS42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, HLS42RGBA_FULL)
@@ -1459,312 +2091,374 @@ TEST_P(CvtColor, HLS42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2YUV)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGB2YUV)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YUV2BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YUV42BGR)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YUV42BGRA)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
 
-    cv::Mat channels[4];
-    cv::split(src, channels);
-    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-    cv::merge(channels, 4, src);
+        cv::Mat channels[4];
+        cv::split(src, channels);
+        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+        cv::merge(channels, 4, src);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, YUV2RGB)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
+    try
+    {
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BGR2YUV4)
 {
-    cv::Mat src = img;
+    try
+    {
+        cv::Mat src = img;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-    cv::Mat h_dst(dst);
+        cv::Mat h_dst(dst);
 
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
 
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, RGBA2YUV4)
 {
-    cv::Mat src;
-    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
-
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
-
-    ASSERT_EQ(4, dst.channels());
-
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
-
-    cv::Mat h_dst(dst);
-
-    cv::Mat channels[4];
-    cv::split(h_dst, channels);
-    cv::merge(channels, 3, h_dst);
-
-    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-}
-
-TEST_P(CvtColor, BGR2Lab)
-{
-    if (depth != CV_8U)
-        return;
-
     try
     {
-        cv::Mat src = readImage("stereobm/aloe-L.png");
+        cv::Mat src;
+        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
 
-        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
-
-        EXPECT_MAT_NEAR(src, dst_bgr, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
-}
-
-TEST_P(CvtColor, RGB2Lab)
-{
-    if (depth != CV_8U)
-        return;
-
-    try
-    {
-        cv::Mat src = readImage("stereobm/aloe-L.png");
-
-        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
-
-        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
-
-        EXPECT_MAT_NEAR(src, dst_bgr, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
-}
-
-TEST_P(CvtColor, BGR2Luv)
-{
-    if (depth != CV_8U)
-        return;
-
-    try
-    {
-        cv::Mat src = img;
-
-        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
-
-        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
-
-        EXPECT_MAT_NEAR(src, dst_rgb, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
-}
-
-TEST_P(CvtColor, RGB2Luv)
-{
-    if (depth != CV_8U)
-        return;
-
-    try
-    {
-        cv::Mat src = img;
-
-        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
-
-        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
-
-        EXPECT_MAT_NEAR(src, dst_rgb, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
-}
-
-TEST_P(CvtColor, RGBA2mRGBA)
-{
-    if (depth != CV_8U)
-        return;
-
-    try
-    {
-        cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
-
-        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
+        ASSERT_EQ(4, dst.channels());
 
         cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1);
+        cv::Mat h_dst(dst);
+
+        cv::Mat channels[4];
+        cv::split(h_dst, channels);
+        cv::merge(channels, 3, h_dst);
+
+        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
     }
-    catch (const cv::Exception& e)
+    catch (...)
     {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
+#if defined(CUDA_VERSION) && (CUDA_VERSION >= 5000)
+    TEST_P(CvtColor, BGR2Lab)
+    {
+        if (depth != CV_8U)
+            return;
+
+        try
+        {
+            cv::Mat src = readImage("stereobm/aloe-L.png");
+
+            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
+
+            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
+
+            EXPECT_MAT_NEAR(src, dst_bgr, 10);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
+    }
+
+    TEST_P(CvtColor, RGB2Lab)
+    {
+        if (depth != CV_8U)
+            return;
+
+        try
+        {
+            cv::Mat src = readImage("stereobm/aloe-L.png");
+
+            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
+
+            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
+
+            EXPECT_MAT_NEAR(src, dst_bgr, 10);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
+    }
+
+    TEST_P(CvtColor, BGR2Luv)
+    {
+        if (depth != CV_8U)
+            return;
+
+        try
+        {
+            cv::Mat src = img;
+
+            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
+
+            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
+
+            EXPECT_MAT_NEAR(src, dst_rgb, 10);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
+    }
+
+    TEST_P(CvtColor, RGB2Luv)
+    {
+        if (depth != CV_8U)
+            return;
+
+        try
+        {
+            cv::Mat src = img;
+
+            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
+
+            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
+
+            EXPECT_MAT_NEAR(src, dst_rgb, 10);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
+    }
+
+    TEST_P(CvtColor, RGBA2mRGBA)
+    {
+        if (depth != CV_8U)
+            return;
+
+        try
+        {
+            cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
+
+            cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+            cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
+
+            cv::Mat dst_gold;
+            cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 1);
+        }
+        catch (...)
+        {
+            cv::gpu::resetDevice();
+            throw;
+        }
+    }
+#endif
+
 TEST_P(CvtColor, BayerBG2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerBG2BGR4)
@@ -1772,22 +2466,30 @@ TEST_P(CvtColor, BayerBG2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
-    cv::Mat dst4(dst);
-    cv::Mat dst3;
-    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+        cv::Mat dst4(dst);
+        cv::Mat dst3;
+        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerGB2BGR)
@@ -1795,15 +2497,23 @@ TEST_P(CvtColor, BayerGB2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerGB2BGR4)
@@ -1811,21 +2521,29 @@ TEST_P(CvtColor, BayerGB2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-    cv::Mat dst4(dst);
-    cv::Mat dst3;
-    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+        cv::Mat dst4(dst);
+        cv::Mat dst3;
+        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerRG2BGR)
@@ -1833,15 +2551,23 @@ TEST_P(CvtColor, BayerRG2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerRG2BGR4)
@@ -1849,21 +2575,29 @@ TEST_P(CvtColor, BayerRG2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-    cv::Mat dst4(dst);
-    cv::Mat dst3;
-    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+        cv::Mat dst4(dst);
+        cv::Mat dst3;
+        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerGR2BGR)
@@ -1871,15 +2605,23 @@ TEST_P(CvtColor, BayerGR2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CvtColor, BayerGR2BGR4)
@@ -1887,21 +2629,29 @@ TEST_P(CvtColor, BayerGR2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
 
-    ASSERT_EQ(4, dst.channels());
+        ASSERT_EQ(4, dst.channels());
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-    cv::Mat dst4(dst);
-    cv::Mat dst3;
-    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+        cv::Mat dst4(dst);
+        cv::Mat dst3;
+        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
@@ -1931,18 +2681,26 @@ PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(SwapChannels, Accuracy)
 {
-    cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
-    ASSERT_FALSE(src.empty());
+    try
+    {
+        cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
+        ASSERT_FALSE(src.empty());
 
-    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
 
-    const int dstOrder[] = {2, 1, 0, 3};
-    cv::gpu::swapChannels(d_src, dstOrder);
+        const int dstOrder[] = {2, 1, 0, 3};
+        cv::gpu::swapChannels(d_src, dstOrder);
 
-    cv::Mat dst_gold;
-    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-    EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp
index 0efd9ec68..7c9bb3554 100644
--- a/modules/gpu/test/test_copy_make_border.cpp
+++ b/modules/gpu/test/test_copy_make_border.cpp
@@ -71,16 +71,24 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
 
 TEST_P(CopyMakeBorder, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Scalar val = randomScalar(0, 255);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Scalar val = randomScalar(0, 255);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
-    cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
+        cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
+        cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
 
-    cv::Mat dst_gold;
-    cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
+        cv::Mat dst_gold;
+        cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index 695ec9758..d943ec7e7 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -70,36 +70,44 @@ PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Merge, Accuracy)
 {
-    std::vector<cv::Mat> src;
-    src.reserve(channels);
-    for (int i = 0; i < channels; ++i)
-        src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
-
-    std::vector<cv::gpu::GpuMat> d_src;
-    for (int i = 0; i < channels; ++i)
-        d_src.push_back(loadMat(src[i], useRoi));
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        std::vector<cv::Mat> src;
+        src.reserve(channels);
+        for (int i = 0; i < channels; ++i)
+            src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
+
+        std::vector<cv::gpu::GpuMat> d_src;
+        for (int i = 0; i < channels; ++i)
+            d_src.push_back(loadMat(src[i], useRoi));
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::merge(d_src, dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             cv::gpu::GpuMat dst;
             cv::gpu::merge(d_src, dst);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+
+            cv::Mat dst_gold;
+            cv::merge(src, dst_gold);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst;
-        cv::gpu::merge(d_src, dst);
-
-        cv::Mat dst_gold;
-        cv::merge(src, dst_gold);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -139,34 +147,42 @@ PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Split, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, type);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                std::vector<cv::gpu::GpuMat> dst;
+                cv::gpu::split(loadMat(src), dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             std::vector<cv::gpu::GpuMat> dst;
-            cv::gpu::split(loadMat(src), dst);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::split(loadMat(src, useRoi), dst);
+
+            std::vector<cv::Mat> dst_gold;
+            cv::split(src, dst_gold);
+
+            ASSERT_EQ(dst_gold.size(), dst.size());
+
+            for (size_t i = 0; i < dst_gold.size(); ++i)
+            {
+                EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
+            }
         }
     }
-    else
+    catch (...)
     {
-        std::vector<cv::gpu::GpuMat> dst;
-        cv::gpu::split(loadMat(src, useRoi), dst);
-
-        std::vector<cv::Mat> dst_gold;
-        cv::split(src, dst_gold);
-
-        ASSERT_EQ(dst_gold.size(), dst.size());
-
-        for (size_t i = 0; i < dst_gold.size(); ++i)
-        {
-            EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
-        }
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -208,31 +224,39 @@ PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, Ma
 
 TEST_P(Add_Array, Accuracy)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+            cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -269,32 +293,40 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Add_Array_Mask, Accuracy)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+            cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::add(mat1, mat2, dst_gold, mask, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -327,62 +359,78 @@ PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, M
 
 TEST_P(Add_Scalar, WithOutMask)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+            cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-        cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Add_Scalar, WithMask)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+            cv::add(mat, val, dst_gold, mask, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-        cv::add(mat, val, dst_gold, mask, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -423,31 +471,39 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Subtract_Array, Accuracy)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+            cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -484,32 +540,40 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<Ma
 
 TEST_P(Subtract_Array_Mask, Accuracy)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+            cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-        cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -542,62 +606,78 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Subtract_Scalar, WithOutMask)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+            cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-        cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Subtract_Scalar, WithMask)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            dst.setTo(cv::Scalar::all(0));
+            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+            cv::subtract(mat, val, dst_gold, mask, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        dst.setTo(cv::Scalar::all(0));
-        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-        cv::subtract(mat, val, dst_gold, mask, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -638,60 +718,76 @@ PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Multiply_Array, WithOutScale)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+            cv::Mat dst_gold;
+            cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-        cv::Mat dst_gold;
-        cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Multiply_Array, WithScale)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype);
-    double scale = randomDouble(0.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype);
+        double scale = randomDouble(0.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+            cv::Mat dst_gold;
+            cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-        cv::Mat dst_gold;
-        cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -723,76 +819,92 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
 {
-    cv::Mat mat1 = randomMat(size, CV_8UC4);
-    cv::Mat mat2 = randomMat(size, CV_32FC1);
-
-    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-    cv::Mat h_dst(dst);
-
-    for (int y = 0; y < h_dst.rows; ++y)
+    try
     {
-        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-        const float* mat2_row = mat2.ptr<float>(y);
-        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+        cv::Mat mat1 = randomMat(size, CV_8UC4);
+        cv::Mat mat2 = randomMat(size, CV_32FC1);
 
-        for (int x = 0; x < h_dst.cols; ++x)
+        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+        cv::Mat h_dst(dst);
+
+        for (int y = 0; y < h_dst.rows; ++y)
         {
-            cv::Vec4b val1 = mat1_row[x];
-            float val2 = mat2_row[x];
-            cv::Vec4b actual = dst_row[x];
+            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+            const float* mat2_row = mat2.ptr<float>(y);
+            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-            cv::Vec4b gold;
+            for (int x = 0; x < h_dst.cols; ++x)
+            {
+                cv::Vec4b val1 = mat1_row[x];
+                float val2 = mat2_row[x];
+                cv::Vec4b actual = dst_row[x];
 
-            gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
-            gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
-            gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
-            gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
+                cv::Vec4b gold;
 
-            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
+                gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
+                gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
+                gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
+
+                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            }
         }
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
 {
-    cv::Mat mat1 = randomMat(size, CV_16SC4);
-    cv::Mat mat2 = randomMat(size, CV_32FC1);
-
-    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-    cv::Mat h_dst(dst);
-
-    for (int y = 0; y < h_dst.rows; ++y)
+    try
     {
-        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-        const float* mat2_row = mat2.ptr<float>(y);
-        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+        cv::Mat mat1 = randomMat(size, CV_16SC4);
+        cv::Mat mat2 = randomMat(size, CV_32FC1);
 
-        for (int x = 0; x < h_dst.cols; ++x)
+        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+        cv::Mat h_dst(dst);
+
+        for (int y = 0; y < h_dst.rows; ++y)
         {
-            cv::Vec4s val1 = mat1_row[x];
-            float val2 = mat2_row[x];
-            cv::Vec4s actual = dst_row[x];
+            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+            const float* mat2_row = mat2.ptr<float>(y);
+            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-            cv::Vec4s gold;
+            for (int x = 0; x < h_dst.cols; ++x)
+            {
+                cv::Vec4s val1 = mat1_row[x];
+                float val2 = mat2_row[x];
+                cv::Vec4s actual = dst_row[x];
 
-            gold[0] = cv::saturate_cast<short>(val1[0] * val2);
-            gold[1] = cv::saturate_cast<short>(val1[1] * val2);
-            gold[2] = cv::saturate_cast<short>(val1[2] * val2);
-            gold[3] = cv::saturate_cast<short>(val1[3] * val2);
+                cv::Vec4s gold;
 
-            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                gold[0] = cv::saturate_cast<short>(val1[0] * val2);
+                gold[1] = cv::saturate_cast<short>(val1[1] * val2);
+                gold[2] = cv::saturate_cast<short>(val1[2] * val2);
+                gold[3] = cv::saturate_cast<short>(val1[3] * val2);
+
+                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            }
         }
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Multiply_Array_Special, testing::Combine(
@@ -823,61 +935,77 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Multiply_Scalar, WithOutScale)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+            cv::Mat dst_gold;
+            cv::multiply(mat, val, dst_gold, 1, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-        cv::Mat dst_gold;
-        cv::multiply(mat, val, dst_gold, 1, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 
 TEST_P(Multiply_Scalar, WithScale)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(0, 255);
-    double scale = randomDouble(0.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(0, 255);
+        double scale = randomDouble(0.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+            cv::Mat dst_gold;
+            cv::multiply(mat, val, dst_gold, scale, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-        cv::Mat dst_gold;
-        cv::multiply(mat, val, dst_gold, scale, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -918,61 +1046,77 @@ PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth,
 
 TEST_P(Divide_Array, WithOutScale)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+            cv::Mat dst_gold;
+            cv::divide(mat1, mat2, dst_gold, 1, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-        cv::Mat dst_gold;
-        cv::divide(mat1, mat2, dst_gold, 1, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 
 TEST_P(Divide_Array, WithScale)
 {
-    cv::Mat mat1 = randomMat(size, stype);
-    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-    double scale = randomDouble(0.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat1 = randomMat(size, stype);
+        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+        double scale = randomDouble(0.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+            cv::Mat dst_gold;
+            cv::divide(mat1, mat2, dst_gold, scale, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-        cv::Mat dst_gold;
-        cv::divide(mat1, mat2, dst_gold, scale, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1004,76 +1148,92 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
 {
-    cv::Mat mat1 = randomMat(size, CV_8UC4);
-    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
-
-    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-    cv::Mat h_dst(dst);
-
-    for (int y = 0; y < h_dst.rows; ++y)
+    try
     {
-        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-        const float* mat2_row = mat2.ptr<float>(y);
-        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+        cv::Mat mat1 = randomMat(size, CV_8UC4);
+        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
 
-        for (int x = 0; x < h_dst.cols; ++x)
+        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+        cv::Mat h_dst(dst);
+
+        for (int y = 0; y < h_dst.rows; ++y)
         {
-            cv::Vec4b val1 = mat1_row[x];
-            float val2 = mat2_row[x];
-            cv::Vec4b actual = dst_row[x];
+            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+            const float* mat2_row = mat2.ptr<float>(y);
+            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-            cv::Vec4b gold;
+            for (int x = 0; x < h_dst.cols; ++x)
+            {
+                cv::Vec4b val1 = mat1_row[x];
+                float val2 = mat2_row[x];
+                cv::Vec4b actual = dst_row[x];
 
-            gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
-            gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
-            gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
-            gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
+                cv::Vec4b gold;
 
-            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
+                gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
+                gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
+                gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
+
+                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            }
         }
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
 {
-    cv::Mat mat1 = randomMat(size, CV_16SC4);
-    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
-
-    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-    cv::Mat h_dst(dst);
-
-    for (int y = 0; y < h_dst.rows; ++y)
+    try
     {
-        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-        const float* mat2_row = mat2.ptr<float>(y);
-        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+        cv::Mat mat1 = randomMat(size, CV_16SC4);
+        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
 
-        for (int x = 0; x < h_dst.cols; ++x)
+        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+        cv::Mat h_dst(dst);
+
+        for (int y = 0; y < h_dst.rows; ++y)
         {
-            cv::Vec4s val1 = mat1_row[x];
-            float val2 = mat2_row[x];
-            cv::Vec4s actual = dst_row[x];
+            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+            const float* mat2_row = mat2.ptr<float>(y);
+            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-            cv::Vec4s gold;
+            for (int x = 0; x < h_dst.cols; ++x)
+            {
+                cv::Vec4s val1 = mat1_row[x];
+                float val2 = mat2_row[x];
+                cv::Vec4s actual = dst_row[x];
 
-            gold[0] = cv::saturate_cast<short>(val1[0] / val2);
-            gold[1] = cv::saturate_cast<short>(val1[1] / val2);
-            gold[2] = cv::saturate_cast<short>(val1[2] / val2);
-            gold[3] = cv::saturate_cast<short>(val1[3] / val2);
+                cv::Vec4s gold;
 
-            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                gold[0] = cv::saturate_cast<short>(val1[0] / val2);
+                gold[1] = cv::saturate_cast<short>(val1[1] / val2);
+                gold[2] = cv::saturate_cast<short>(val1[2] / val2);
+                gold[3] = cv::saturate_cast<short>(val1[3] / val2);
+
+                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            }
         }
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Divide_Array_Special, testing::Combine(
@@ -1104,60 +1264,76 @@ PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth
 
 TEST_P(Divide_Scalar, WithOutScale)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(1.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(1.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+            cv::Mat dst_gold;
+            cv::divide(mat, val, dst_gold, 1, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-        cv::Mat dst_gold;
-        cv::divide(mat, val, dst_gold, 1, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Divide_Scalar, WithScale)
 {
-    cv::Mat mat = randomMat(size, depth.first);
-    cv::Scalar val = randomScalar(1.0, 255.0);
-    double scale = randomDouble(0.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat mat = randomMat(size, depth.first);
+        cv::Scalar val = randomScalar(1.0, 255.0);
+        double scale = randomDouble(0.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+            cv::Mat dst_gold;
+            cv::divide(mat, val, dst_gold, scale, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-        cv::Mat dst_gold;
-        cv::divide(mat, val, dst_gold, scale, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1190,30 +1366,38 @@ PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatD
 
 TEST_P(Divide_Scalar_Inv, Accuracy)
 {
-    double scale = randomDouble(0.0, 255.0);
-    cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
-
-    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        double scale = randomDouble(0.0, 255.0);
+        cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
+
+        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+            cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
+
+            cv::Mat dst_gold;
+            cv::divide(scale, mat, dst_gold, depth.second);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-        cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
-
-        cv::Mat dst_gold;
-        cv::divide(scale, mat, dst_gold, depth.second);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1246,59 +1430,75 @@ PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(AbsDiff, Array)
 {
-    cv::Mat src1 = randomMat(size, depth);
-    cv::Mat src2 = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src1 = randomMat(size, depth);
+        cv::Mat src2 = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+            cv::Mat dst_gold;
+            cv::absdiff(src1, src2, dst_gold);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-        cv::Mat dst_gold;
-        cv::absdiff(src1, src2, dst_gold);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(AbsDiff, Scalar)
 {
-    cv::Mat src = randomMat(size, depth);
-    cv::Scalar val = randomScalar(0.0, 255.0);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+        cv::Scalar val = randomScalar(0.0, 255.0);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::absdiff(loadMat(src), val, dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::absdiff(loadMat(src), val, dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
+
+            cv::Mat dst_gold;
+            cv::absdiff(src, val, dst_gold);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
-
-        cv::Mat dst_gold;
-        cv::absdiff(src, val, dst_gold);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1331,14 +1531,22 @@ PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Abs, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-    cv::gpu::abs(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::abs(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold = cv::abs(src);
+        cv::Mat dst_gold = cv::abs(src);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
@@ -1370,15 +1578,23 @@ PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqr, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
+    try
+    {
+        cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
 
-    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-    cv::gpu::sqr(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::sqr(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::multiply(src, src, dst_gold);
+        cv::Mat dst_gold;
+        cv::multiply(src, src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
@@ -1437,15 +1653,23 @@ PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqrt, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-    cv::gpu::sqrt(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::sqrt(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    sqrtGold(src, dst_gold);
+        cv::Mat dst_gold;
+        sqrtGold(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
@@ -1504,15 +1728,23 @@ PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Log, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth, 1.0, 255.0);
+    try
+    {
+        cv::Mat src = randomMat(size, depth, 1.0, 255.0);
 
-    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-    cv::gpu::log(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::log(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    logGold(src, dst_gold);
+        cv::Mat dst_gold;
+        logGold(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
@@ -1581,15 +1813,23 @@ PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Exp, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+    try
+    {
+        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
 
-    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-    cv::gpu::exp(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::exp(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    expGold(src, dst_gold);
+        cv::Mat dst_gold;
+        expGold(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
+        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
@@ -1629,30 +1869,38 @@ PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode,
 
 TEST_P(Compare_Array, Accuracy)
 {
-    cv::Mat src1 = randomMat(size, depth);
-    cv::Mat src2 = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src1 = randomMat(size, depth);
+        cv::Mat src2 = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
+            cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
+
+            cv::Mat dst_gold;
+            cv::compare(src1, src2, dst_gold, cmp_code);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
-        cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
-
-        cv::Mat dst_gold;
-        cv::compare(src1, src2, dst_gold, cmp_code);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1731,39 +1979,47 @@ PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode,
 
 TEST_P(Compare_Scalar, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Scalar sc = randomScalar(0.0, 255.0);
-
-    if (src.depth() < CV_32F)
+    try
     {
-        sc.val[0] = cvRound(sc.val[0]);
-        sc.val[1] = cvRound(sc.val[1]);
-        sc.val[2] = cvRound(sc.val[2]);
-        sc.val[3] = cvRound(sc.val[3]);
-    }
+        cv::Mat src = randomMat(size, type);
+        cv::Scalar sc = randomScalar(0.0, 255.0);
 
-    if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-    {
-        try
+        if (src.depth() < CV_32F)
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
+            sc.val[0] = cvRound(sc.val[0]);
+            sc.val[1] = cvRound(sc.val[1]);
+            sc.val[2] = cvRound(sc.val[2]);
+            sc.val[3] = cvRound(sc.val[3]);
         }
-        catch (const cv::Exception& e)
+
+        if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
+        {
+            cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
+
+            cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
+
+            cv::Mat dst_gold;
+            compareScalarGold(src, sc, dst_gold, cmp_code);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
-
-        cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
-
-        cv::Mat dst_gold;
-        compareScalarGold(src, sc, dst_gold, cmp_code);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1801,42 +2057,74 @@ PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(Bitwise_Array, Not)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_not(loadMat(src1), dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_not(loadMat(src1), dst);
 
-    cv::Mat dst_gold = ~src1;
+        cv::Mat dst_gold = ~src1;
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Bitwise_Array, Or)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
 
-    cv::Mat dst_gold = src1 | src2;
+        cv::Mat dst_gold = src1 | src2;
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Bitwise_Array, And)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
 
-    cv::Mat dst_gold = src1 & src2;
+        cv::Mat dst_gold = src1 & src2;
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Bitwise_Array, Xor)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
 
-    cv::Mat dst_gold = src1 ^ src2;
+        cv::Mat dst_gold = src1 ^ src2;
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Array, testing::Combine(
@@ -1874,35 +2162,59 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channel
 
 TEST_P(Bitwise_Scalar, Or)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_or(loadMat(src), val, dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_or(loadMat(src), val, dst);
 
-    cv::Mat dst_gold;
-    cv::bitwise_or(src, val, dst_gold);
+        cv::Mat dst_gold;
+        cv::bitwise_or(src, val, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Bitwise_Scalar, And)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_and(loadMat(src), val, dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_and(loadMat(src), val, dst);
 
-    cv::Mat dst_gold;
-    cv::bitwise_and(src, val, dst_gold);
+        cv::Mat dst_gold;
+        cv::bitwise_and(src, val, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Bitwise_Scalar, Xor)
 {
-    cv::gpu::GpuMat dst;
-    cv::gpu::bitwise_xor(loadMat(src), val, dst);
+    try
+    {
+        cv::gpu::GpuMat dst;
+        cv::gpu::bitwise_xor(loadMat(src), val, dst);
 
-    cv::Mat dst_gold;
-    cv::bitwise_xor(src, val, dst_gold);
+        cv::Mat dst_gold;
+        cv::bitwise_xor(src, val, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
@@ -1964,17 +2276,25 @@ PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(RShift, Accuracy)
 {
-    int type = CV_MAKE_TYPE(depth, channels);
-    cv::Mat src = randomMat(size, type);
-    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    try
+    {
+        int type = CV_MAKE_TYPE(depth, channels);
+        cv::Mat src = randomMat(size, type);
+        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::rshift(loadMat(src, useRoi), val, dst);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::rshift(loadMat(src, useRoi), val, dst);
 
-    cv::Mat dst_gold;
-    rhiftGold(src, val, dst_gold);
+        cv::Mat dst_gold;
+        rhiftGold(src, val, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine(
@@ -2041,17 +2361,25 @@ PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(LShift, Accuracy)
 {
-    int type = CV_MAKE_TYPE(depth, channels);
-    cv::Mat src = randomMat(size, type);
-    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    try
+    {
+        int type = CV_MAKE_TYPE(depth, channels);
+        cv::Mat src = randomMat(size, type);
+        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::lshift(loadMat(src, useRoi), val, dst);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::lshift(loadMat(src, useRoi), val, dst);
 
-    cv::Mat dst_gold;
-    lhiftGold(src, val, dst_gold);
+        cv::Mat dst_gold;
+        lhiftGold(src, val, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LShift, testing::Combine(
@@ -2084,57 +2412,73 @@ PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Min, Array)
 {
-    cv::Mat src1 = randomMat(size, depth);
-    cv::Mat src2 = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src1 = randomMat(size, depth);
+        cv::Mat src2 = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::min(loadMat(src1), loadMat(src2), dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::min(loadMat(src1), loadMat(src2), dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+            cv::Mat dst_gold = cv::min(src1, src2);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-        cv::Mat dst_gold = cv::min(src1, src2);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Min, Scalar)
 {
-    cv::Mat src = randomMat(size, depth);
-    double val = randomDouble(0.0, 255.0);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+        double val = randomDouble(0.0, 255.0);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::min(loadMat(src), val, dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::min(loadMat(src), val, dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::min(loadMat(src, useRoi), val, dst);
+
+            cv::Mat dst_gold = cv::min(src, val);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::min(loadMat(src, useRoi), val, dst);
-
-        cv::Mat dst_gold = cv::min(src, val);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2167,57 +2511,73 @@ PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Max, Array)
 {
-    cv::Mat src1 = randomMat(size, depth);
-    cv::Mat src2 = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src1 = randomMat(size, depth);
+        cv::Mat src2 = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::max(loadMat(src1), loadMat(src2), dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::max(loadMat(src1), loadMat(src2), dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+            cv::Mat dst_gold = cv::max(src1, src2);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-        cv::Mat dst_gold = cv::max(src1, src2);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(Max, Scalar)
 {
-    cv::Mat src = randomMat(size, depth);
-    double val = randomDouble(0.0, 255.0);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+        double val = randomDouble(0.0, 255.0);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::max(loadMat(src), val, dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::max(loadMat(src), val, dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::max(loadMat(src, useRoi), val, dst);
+
+            cv::Mat dst_gold = cv::max(src, val);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::max(loadMat(src, useRoi), val, dst);
-
-        cv::Mat dst_gold = cv::max(src, val);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2250,33 +2610,41 @@ PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Pow, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
-    double power = randomDouble(2.0, 4.0);
-
-    if (src.depth() < CV_32F)
-        power = static_cast<int>(power);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+        double power = randomDouble(2.0, 4.0);
+
+        if (src.depth() < CV_32F)
+            power = static_cast<int>(power);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::pow(loadMat(src), power, dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::pow(loadMat(src), power, dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+            cv::gpu::pow(loadMat(src, useRoi), power, dst);
+
+            cv::Mat dst_gold;
+            cv::pow(src, power, dst_gold);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::pow(loadMat(src, useRoi), power, dst);
-
-        cv::Mat dst_gold;
-        cv::pow(src, power, dst_gold);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2313,33 +2681,41 @@ PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth,
 
 TEST_P(AddWeighted, Accuracy)
 {
-    cv::Mat src1 = randomMat(size, depth1);
-    cv::Mat src2 = randomMat(size, depth2);
-    double alpha = randomDouble(-10.0, 10.0);
-    double beta = randomDouble(-10.0, 10.0);
-    double gamma = randomDouble(-10.0, 10.0);
-
-    if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src1 = randomMat(size, depth1);
+        cv::Mat src2 = randomMat(size, depth2);
+        double alpha = randomDouble(-10.0, 10.0);
+        double beta = randomDouble(-10.0, 10.0);
+        double gamma = randomDouble(-10.0, 10.0);
+
+        if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
+            cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
+
+            cv::Mat dst_gold;
+            cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
-        cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
-
-        cv::Mat dst_gold;
-        cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2354,6 +2730,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // GEMM
 
+#ifdef HAVE_CUBLAS
+
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
 #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
 
@@ -2379,58 +2757,54 @@ PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
 
 TEST_P(GEMM, Accuracy)
 {
-    cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
-    cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
-    cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
-    double alpha = randomDouble(-10.0, 10.0);
-    double beta = randomDouble(-10.0, 10.0);
-
-#ifndef HAVE_CUBLAS
     try
     {
-        cv::gpu::GpuMat dst;
-        cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-    }
-    catch (const cv::Exception& e)
-    {
-        ASSERT_EQ(CV_StsNotImplemented, e.code);
-    }
-#else
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-    {
-        try
-        {
-            cv::gpu::GpuMat dst;
-            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-        }
-    }
-    else if (type == CV_64FC2 && flags != 0)
-    {
-        try
-        {
-            cv::gpu::GpuMat dst;
-            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
-    {
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
+        cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
+        cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
+        cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
+        double alpha = randomDouble(-10.0, 10.0);
+        double beta = randomDouble(-10.0, 10.0);
 
-        cv::Mat dst_gold;
-        cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else if (type == CV_64FC2 && flags != 0)
+        {
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsNotImplemented, e.code);
+            }
+        }
+        else
+        {
+            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+            cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+            cv::Mat dst_gold;
+            cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
@@ -2440,6 +2814,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
     ALL_GEMM_FLAGS,
     WHOLE_SUBMAT));
 
+#endif // HAVE_CUBLAS
+
 ////////////////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -2463,29 +2839,37 @@ PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Transpose, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, type);
+
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::transpose(loadMat(src), dst);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::transpose(loadMat(src), dst);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
+            cv::gpu::transpose(loadMat(src, useRoi), dst);
+
+            cv::Mat dst_gold;
+            cv::transpose(src, dst_gold);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
-        cv::gpu::transpose(loadMat(src, useRoi), dst);
-
-        cv::Mat dst_gold;
-        cv::transpose(src, dst_gold);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2530,15 +2914,23 @@ PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
 
 TEST_P(Flip, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
 
-    cv::Mat dst_gold;
-    cv::flip(src, dst_gold, flip_code);
+        cv::Mat dst_gold;
+        cv::flip(src, dst_gold, flip_code);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Flip, testing::Combine(
@@ -2582,30 +2974,46 @@ PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(LUT, OneChannel)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
-    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
+        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-    cv::Mat dst_gold;
-    cv::LUT(src, lut, dst_gold);
+        cv::Mat dst_gold;
+        cv::LUT(src, lut, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(LUT, MultiChannel)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
 
-    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
-    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
+        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-    cv::Mat dst_gold;
-    cv::LUT(src, lut, dst_gold);
+        cv::Mat dst_gold;
+        cv::LUT(src, lut, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LUT, testing::Combine(
@@ -2635,62 +3043,94 @@ PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Magnitude, NPP)
 {
-    cv::Mat src = randomMat(size, CV_32FC2);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_32FC2);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::magnitude(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::magnitude(loadMat(src, useRoi), dst);
 
-    cv::Mat arr[2];
-    cv::split(src, arr);
-    cv::Mat dst_gold;
-    cv::magnitude(arr[0], arr[1], dst_gold);
+        cv::Mat arr[2];
+        cv::split(src, arr);
+        cv::Mat dst_gold;
+        cv::magnitude(arr[0], arr[1], dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Magnitude, Sqr_NPP)
 {
-    cv::Mat src = randomMat(size, CV_32FC2);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_32FC2);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
 
-    cv::Mat arr[2];
-    cv::split(src, arr);
-    cv::Mat dst_gold;
-    cv::magnitude(arr[0], arr[1], dst_gold);
-    cv::multiply(dst_gold, dst_gold, dst_gold);
+        cv::Mat arr[2];
+        cv::split(src, arr);
+        cv::Mat dst_gold;
+        cv::magnitude(arr[0], arr[1], dst_gold);
+        cv::multiply(dst_gold, dst_gold, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Magnitude, Accuracy)
 {
-    cv::Mat x = randomMat(size, CV_32FC1);
-    cv::Mat y = randomMat(size, CV_32FC1);
+    try
+    {
+        cv::Mat x = randomMat(size, CV_32FC1);
+        cv::Mat y = randomMat(size, CV_32FC1);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::magnitude(x, y, dst_gold);
+        cv::Mat dst_gold;
+        cv::magnitude(x, y, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Magnitude, Sqr_Accuracy)
 {
-    cv::Mat x = randomMat(size, CV_32FC1);
-    cv::Mat y = randomMat(size, CV_32FC1);
+    try
+    {
+        cv::Mat x = randomMat(size, CV_32FC1);
+        cv::Mat y = randomMat(size, CV_32FC1);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::magnitude(x, y, dst_gold);
-    cv::multiply(dst_gold, dst_gold, dst_gold);
+        cv::Mat dst_gold;
+        cv::magnitude(x, y, dst_gold);
+        cv::multiply(dst_gold, dst_gold, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine(
@@ -2723,16 +3163,24 @@ PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
 
 TEST_P(Phase, Accuracy)
 {
-    cv::Mat x = randomMat(size, CV_32FC1);
-    cv::Mat y = randomMat(size, CV_32FC1);
+    try
+    {
+        cv::Mat x = randomMat(size, CV_32FC1);
+        cv::Mat y = randomMat(size, CV_32FC1);
 
-    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
+        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
 
-    cv::Mat dst_gold;
-    cv::phase(x, y, dst_gold, angleInDegrees);
+        cv::Mat dst_gold;
+        cv::phase(x, y, dst_gold, angleInDegrees);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
+        EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Phase, testing::Combine(
@@ -2764,19 +3212,27 @@ PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(CartToPolar, Accuracy)
 {
-    cv::Mat x = randomMat(size, CV_32FC1);
-    cv::Mat y = randomMat(size, CV_32FC1);
+    try
+    {
+        cv::Mat x = randomMat(size, CV_32FC1);
+        cv::Mat y = randomMat(size, CV_32FC1);
 
-    cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
+        cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
 
-    cv::Mat mag_gold;
-    cv::Mat angle_gold;
-    cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
+        cv::Mat mag_gold;
+        cv::Mat angle_gold;
+        cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
 
-    EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
-    EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
+        EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+        EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, CartToPolar, testing::Combine(
@@ -2808,19 +3264,27 @@ PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(PolarToCart, Accuracy)
 {
-    cv::Mat magnitude = randomMat(size, CV_32FC1);
-    cv::Mat angle = randomMat(size, CV_32FC1);
+    try
+    {
+        cv::Mat magnitude = randomMat(size, CV_32FC1);
+        cv::Mat angle = randomMat(size, CV_32FC1);
 
-    cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
-    cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
+        cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
+        cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
 
-    cv::Mat x_gold;
-    cv::Mat y_gold;
-    cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
+        cv::Mat x_gold;
+        cv::Mat y_gold;
+        cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
 
-    EXPECT_MAT_NEAR(x_gold, x, 1e-4);
-    EXPECT_MAT_NEAR(y_gold, y, 1e-4);
+        EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+        EXPECT_MAT_NEAR(y_gold, y, 1e-4);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, PolarToCart, testing::Combine(
@@ -2850,33 +3314,41 @@ PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(MeanStdDev, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_8UC1);
-
-    if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, CV_8UC1);
+
+        if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+        {
+            try
+            {
+                cv::Scalar mean;
+                cv::Scalar stddev;
+                cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsNotImplemented, e.code);
+            }
+        }
+        else
         {
             cv::Scalar mean;
             cv::Scalar stddev;
             cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
+
+            cv::Scalar mean_gold;
+            cv::Scalar stddev_gold;
+            cv::meanStdDev(src, mean_gold, stddev_gold);
+
+            EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
+            EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
         }
     }
-    else
+    catch (...)
     {
-        cv::Scalar mean;
-        cv::Scalar stddev;
-        cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-
-        cv::Scalar mean_gold;
-        cv::Scalar stddev_gold;
-        cv::meanStdDev(src, mean_gold, stddev_gold);
-
-        EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
-        EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -2910,13 +3382,21 @@ PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
 
 TEST_P(Norm, Accuracy)
 {
-    cv::Mat src = randomMat(size, depth);
+    try
+    {
+        cv::Mat src = randomMat(size, depth);
 
-    double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
+        double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
 
-    double val_gold = cv::norm(src, normCode);
+        double val_gold = cv::norm(src, normCode);
 
-    EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
+        EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine(
@@ -2954,14 +3434,22 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
 
 TEST_P(NormDiff, Accuracy)
 {
-    cv::Mat src1 = randomMat(size, CV_8UC1);
-    cv::Mat src2 = randomMat(size, CV_8UC1);
+    try
+    {
+        cv::Mat src1 = randomMat(size, CV_8UC1);
+        cv::Mat src2 = randomMat(size, CV_8UC1);
 
-    double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
+        double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
 
-    double val_gold = cv::norm(src1, src2, normCode);
+        double val_gold = cv::norm(src1, src2, normCode);
 
-    EXPECT_NEAR(val_gold, val, 0.0);
+        EXPECT_NEAR(val_gold, val, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine(
@@ -3074,29 +3562,53 @@ PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Sum, Simple)
 {
-    cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
+    try
+    {
+        cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
 
-    cv::Scalar val_gold = cv::sum(src);
+        cv::Scalar val_gold = cv::sum(src);
 
-    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Sum, Abs)
 {
-    cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
+    try
+    {
+        cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
 
-    cv::Scalar val_gold = absSumGold(src);
+        cv::Scalar val_gold = absSumGold(src);
 
-    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Sum, Sqr)
 {
-    cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
+    try
+    {
+        cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
 
-    cv::Scalar val_gold = sqrSumGold(src);
+        cv::Scalar val_gold = sqrSumGold(src);
 
-    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
@@ -3128,91 +3640,115 @@ PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMax, WithoutMask)
 {
-    cv::Mat src = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
+
+            double minVal_gold, maxVal_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
-
-        double minVal_gold, maxVal_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(MinMax, WithMask)
 {
-    cv::Mat src = randomMat(size, depth);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
+
+            double minVal_gold, maxVal_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
-
-        double minVal_gold, maxVal_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(MinMax, NullPtr)
 {
-    cv::Mat src = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::gpu::minMax(loadMat(src), &minVal, 0);
+                cv::gpu::minMax(loadMat(src), 0, &maxVal);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src), &minVal, 0);
-            cv::gpu::minMax(loadMat(src), 0, &maxVal);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
+            cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
+
+            double minVal_gold, maxVal_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
-        cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
-
-        double minVal_gold, maxVal_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -3269,82 +3805,114 @@ PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMaxLoc, WithoutMask)
 {
-    cv::Mat src = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::Point minLoc, maxLoc;
+                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
+
+            double minVal_gold, maxVal_gold;
+            cv::Point minLoc_gold, maxLoc_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+            expectEqual(src, minLoc_gold, minLoc);
+            expectEqual(src, maxLoc_gold, maxLoc);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
-
-        double minVal_gold, maxVal_gold;
-        cv::Point minLoc_gold, maxLoc_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-        expectEqual(src, minLoc_gold, minLoc);
-        expectEqual(src, maxLoc_gold, maxLoc);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(MinMaxLoc, WithMask)
 {
-    cv::Mat src = randomMat(size, depth);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::Point minLoc, maxLoc;
+                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
+
+            double minVal_gold, maxVal_gold;
+            cv::Point minLoc_gold, maxLoc_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+            expectEqual(src, minLoc_gold, minLoc);
+            expectEqual(src, maxLoc_gold, maxLoc);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
-
-        double minVal_gold, maxVal_gold;
-        cv::Point minLoc_gold, maxLoc_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-        expectEqual(src, minLoc_gold, minLoc);
-        expectEqual(src, maxLoc_gold, maxLoc);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(MinMaxLoc, NullPtr)
 {
-    cv::Mat src = randomMat(size, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                double minVal, maxVal;
+                cv::Point minLoc, maxLoc;
+                cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
@@ -3352,30 +3920,22 @@ TEST_P(MinMaxLoc, NullPtr)
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+
+            double minVal_gold, maxVal_gold;
+            cv::Point minLoc_gold, maxLoc_gold;
+            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+            expectEqual(src, minLoc_gold, minLoc);
+            expectEqual(src, maxLoc_gold, maxLoc);
         }
     }
-    else
+    catch (...)
     {
-        double minVal, maxVal;
-        cv::Point minLoc, maxLoc;
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
-        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-
-        double minVal_gold, maxVal_gold;
-        cv::Point minLoc_gold, maxLoc_gold;
-        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-        expectEqual(src, minLoc_gold, minLoc);
-        expectEqual(src, maxLoc_gold, maxLoc);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -3409,28 +3969,36 @@ PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CountNonZero, Accuracy)
 {
-    cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
-    cv::Mat src;
-    srcBase.convertTo(src, depth);
-
-    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
+        cv::Mat src;
+        srcBase.convertTo(src, depth);
+
+        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::countNonZero(loadMat(src));
+            try
+            {
+                cv::gpu::countNonZero(loadMat(src));
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            int val = cv::gpu::countNonZero(loadMat(src, useRoi));
+
+            int val_gold = cv::countNonZero(src);
+
+            ASSERT_EQ(val_gold, val);
         }
     }
-    else
+    catch (...)
     {
-        int val = cv::gpu::countNonZero(loadMat(src, useRoi));
-
-        int val_gold = cv::countNonZero(src);
-
-        ASSERT_EQ(val_gold, val);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -3486,31 +4054,47 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
 
 TEST_P(Reduce, Rows)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
-    cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
+        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
+        cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
 
-    cv::Mat dst_gold;
-    cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
+        cv::Mat dst_gold;
+        cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(Reduce, Cols)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
-    cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+        cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
+        cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
 
-    cv::Mat dst_gold;
-    cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
-    dst_gold.cols = dst_gold.rows;
-    dst_gold.rows = 1;
-    dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+        cv::Mat dst_gold;
+        cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
+        dst_gold.cols = dst_gold.rows;
+        dst_gold.rows = 1;
+        dst_gold.step = dst_gold.cols * dst_gold.elemSize();
 
-    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
diff --git a/modules/gpu/test/test_denoising.cpp b/modules/gpu/test/test_denoising.cpp
index 80bf3dbe2..5edf973f4 100644
--- a/modules/gpu/test/test_denoising.cpp
+++ b/modules/gpu/test/test_denoising.cpp
@@ -71,17 +71,25 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(BilateralFilter, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    src.convertTo(src, type);
-    cv::gpu::GpuMat dst;
+        src.convertTo(src, type);
+        cv::gpu::GpuMat dst;
 
-    cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
+        cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
 
-    cv::Mat dst_gold;
-    cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
+        cv::Mat dst_gold;
+        cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
@@ -107,35 +115,41 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BruteForceNonLocalMeans, Regression)
 {
-    using cv::gpu::GpuMat;
+    try
+    {
+        using cv::gpu::GpuMat;
 
-    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-    ASSERT_FALSE(bgr.empty());
+        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+        ASSERT_FALSE(bgr.empty());
 
-    cv::Mat gray;
-    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+        cv::Mat gray;
+        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-    GpuMat dbgr, dgray;
-    cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
-    cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
+        GpuMat dbgr, dgray;
+        cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
+        cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
 
-#if 0
-    dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-    dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
-#endif
+    #if 0
+        dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+        dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
+    #endif
 
-    cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-    cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+        cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+        cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
-    EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
+        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
+        EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
 
-
-
 ////////////////////////////////////////////////////////
 // Fast Force Non local means
 
@@ -152,34 +166,41 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastNonLocalMeans, Regression)
 {
-    using cv::gpu::GpuMat;
+    try
+    {
+        using cv::gpu::GpuMat;
 
-    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-    ASSERT_FALSE(bgr.empty());
+        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+        ASSERT_FALSE(bgr.empty());
 
-    cv::Mat gray;
-    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+        cv::Mat gray;
+        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-    GpuMat dbgr, dgray;
-    cv::gpu::FastNonLocalMeansDenoising fnlmd;
+        GpuMat dbgr, dgray;
+        cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-    fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
-    fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
+        fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
+        fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
 
-#if 0
-    //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-    //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
-#endif
+    #if 0
+        //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+        //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
+    #endif
 
-    cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-    cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+        cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+        cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
-    EXPECT_MAT_NEAR(gray_gold, dgray, 1);
+        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
+        EXPECT_MAT_NEAR(gray_gold, dgray, 1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
 
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index c76fe9166..a20ae68b4 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -180,31 +180,19 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
 
 TEST_P(SURF, Detector)
 {
-    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::gpu::SURF_GPU surf;
-    surf.hessianThreshold = hessianThreshold;
-    surf.nOctaves = nOctaves;
-    surf.nOctaveLayers = nOctaveLayers;
-    surf.extended = extended;
-    surf.upright = upright;
-    surf.keypointsRatio = 0.05f;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector<cv::KeyPoint> keypoints;
-            surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        cv::gpu::SURF_GPU surf;
+        surf.hessianThreshold = hessianThreshold;
+        surf.nOctaves = nOctaves;
+        surf.nOctaveLayers = nOctaveLayers;
+        surf.extended = extended;
+        surf.upright = upright;
+        surf.keypointsRatio = 0.05f;
+
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -224,38 +212,31 @@ TEST_P(SURF, Detector)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(SURF, Detector_Masked)
 {
-    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
-
-    cv::gpu::SURF_GPU surf;
-    surf.hessianThreshold = hessianThreshold;
-    surf.nOctaves = nOctaves;
-    surf.nOctaveLayers = nOctaveLayers;
-    surf.extended = extended;
-    surf.upright = upright;
-    surf.keypointsRatio = 0.05f;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector<cv::KeyPoint> keypoints;
-            surf(loadMat(image), loadMat(mask), keypoints);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+
+        cv::gpu::SURF_GPU surf;
+        surf.hessianThreshold = hessianThreshold;
+        surf.nOctaves = nOctaves;
+        surf.nOctaveLayers = nOctaveLayers;
+        surf.extended = extended;
+        surf.upright = upright;
+        surf.keypointsRatio = 0.05f;
+
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), loadMat(mask), keypoints);
 
@@ -275,43 +256,35 @@ TEST_P(SURF, Detector_Masked)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(SURF, Descriptor)
 {
-    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::gpu::SURF_GPU surf;
-    surf.hessianThreshold = hessianThreshold;
-    surf.nOctaves = nOctaves;
-    surf.nOctaveLayers = nOctaveLayers;
-    surf.extended = extended;
-    surf.upright = upright;
-    surf.keypointsRatio = 0.05f;
-
-    cv::SURF surf_gold;
-    surf_gold.hessianThreshold = hessianThreshold;
-    surf_gold.nOctaves = nOctaves;
-    surf_gold.nOctaveLayers = nOctaveLayers;
-    surf_gold.extended = extended;
-    surf_gold.upright = upright;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector<cv::KeyPoint> keypoints;
-            cv::gpu::GpuMat descriptors;
-            surf(loadMat(image), cv::gpu::GpuMat(), keypoints, descriptors);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        cv::gpu::SURF_GPU surf;
+        surf.hessianThreshold = hessianThreshold;
+        surf.nOctaves = nOctaves;
+        surf.nOctaveLayers = nOctaveLayers;
+        surf.extended = extended;
+        surf.upright = upright;
+        surf.keypointsRatio = 0.05f;
+
+        cv::SURF surf_gold;
+        surf_gold.hessianThreshold = hessianThreshold;
+        surf_gold.nOctaves = nOctaves;
+        surf_gold.nOctaveLayers = nOctaveLayers;
+        surf_gold.extended = extended;
+        surf_gold.upright = upright;
+
         std::vector<cv::KeyPoint> keypoints;
         surf_gold(image, cv::noArray(), keypoints);
 
@@ -330,6 +303,11 @@ TEST_P(SURF, Descriptor)
 
         EXPECT_GT(matchedRatio, 0.6);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
@@ -364,26 +342,14 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
 
 TEST_P(FAST, Accuracy)
 {
-    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::gpu::FAST_GPU fast(threshold);
-    fast.nonmaxSupression = nonmaxSupression;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector<cv::KeyPoint> keypoints;
-            fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        cv::gpu::FAST_GPU fast(threshold);
+        fast.nonmaxSupression = nonmaxSupression;
+
         std::vector<cv::KeyPoint> keypoints;
         fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -392,6 +358,11 @@ TEST_P(FAST, Accuracy)
 
         ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
@@ -445,30 +416,17 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
 
 TEST_P(ORB, Accuracy)
 {
-    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
-
-    cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
-    orb.blurForDescriptor = blurForDescriptor;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector<cv::KeyPoint> keypoints;
-            cv::gpu::GpuMat descriptors;
-            orb(loadMat(image), loadMat(mask), keypoints, descriptors);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+
+        cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
+        orb.blurForDescriptor = blurForDescriptor;
+
         std::vector<cv::KeyPoint> keypoints;
         cv::gpu::GpuMat descriptors;
         orb(loadMat(image), loadMat(mask), keypoints, descriptors);
@@ -488,6 +446,11 @@ TEST_P(ORB, Accuracy)
 
         EXPECT_GT(matchedRatio, 0.35);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB,  testing::Combine(
@@ -570,307 +533,109 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
 
 TEST_P(BruteForceMatcher, Match_Single)
 {
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    cv::gpu::GpuMat mask;
-    if (useMask)
+    try
     {
-        mask.create(query.rows, train.rows, CV_8UC1);
-        mask.setTo(cv::Scalar::all(1));
+        cv::gpu::BFMatcher_GPU matcher(normCode);
+
+        cv::gpu::GpuMat mask;
+        if (useMask)
+        {
+            mask.create(query.rows, train.rows, CV_8UC1);
+            mask.setTo(cv::Scalar::all(1));
+        }
+
+        std::vector<cv::DMatch> matches;
+        matcher.match(loadMat(query), loadMat(train), matches, mask);
+
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+        int badCount = 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            cv::DMatch match = matches[i];
+            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
+                badCount++;
+        }
+
+        ASSERT_EQ(0, badCount);
     }
-
-    std::vector<cv::DMatch> matches;
-    matcher.match(loadMat(query), loadMat(train), matches, mask);
-
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-    int badCount = 0;
-    for (size_t i = 0; i < matches.size(); i++)
+    catch (...)
     {
-        cv::DMatch match = matches[i];
-        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
-            badCount++;
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, Match_Collection)
 {
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    cv::gpu::GpuMat d_train(train);
-
-    // make add() twice to test such case
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-    // prepare masks (make first nearest match illegal)
-    std::vector<cv::gpu::GpuMat> masks(2);
-    for (int mi = 0; mi < 2; mi++)
+    try
     {
-        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
-        for (int di = 0; di < queryDescCount/2; di++)
-            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-    }
+        cv::gpu::BFMatcher_GPU matcher(normCode);
 
-    std::vector<cv::DMatch> matches;
-    if (useMask)
-        matcher.match(cv::gpu::GpuMat(query), matches, masks);
-    else
-        matcher.match(cv::gpu::GpuMat(query), matches);
+        cv::gpu::GpuMat d_train(train);
 
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
 
-    int badCount = 0;
-    int shift = useMask ? 1 : 0;
-    for (size_t i = 0; i < matches.size(); i++)
-    {
-        cv::DMatch match = matches[i];
-
-        if ((int)i < queryDescCount / 2)
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++)
         {
-            bool validQueryIdx = (match.queryIdx == (int)i);
-            bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
-            bool validImgIdx = (match.imgIdx == 0);
-            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                badCount++;
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount/2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
         }
+
+        std::vector<cv::DMatch> matches;
+        if (useMask)
+            matcher.match(cv::gpu::GpuMat(query), matches, masks);
         else
-        {
-            bool validQueryIdx = (match.queryIdx == (int)i);
-            bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
-            bool validImgIdx = (match.imgIdx == 1);
-            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                badCount++;
-        }
-    }
+            matcher.match(cv::gpu::GpuMat(query), matches);
 
-    ASSERT_EQ(0, badCount);
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+        int badCount = 0;
+        int shift = useMask ? 1 : 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            cv::DMatch match = matches[i];
+
+            if ((int)i < queryDescCount / 2)
+            {
+                bool validQueryIdx = (match.queryIdx == (int)i);
+                bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
+                bool validImgIdx = (match.imgIdx == 0);
+                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                    badCount++;
+            }
+            else
+            {
+                bool validQueryIdx = (match.queryIdx == (int)i);
+                bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
+                bool validImgIdx = (match.imgIdx == 1);
+                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                    badCount++;
+            }
+        }
+
+        ASSERT_EQ(0, badCount);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const int knn = 2;
-
-    cv::gpu::GpuMat mask;
-    if (useMask)
+    try
     {
-        mask.create(query.rows, train.rows, CV_8UC1);
-        mask.setTo(cv::Scalar::all(1));
-    }
+        cv::gpu::BFMatcher_GPU matcher(normCode);
 
-    std::vector< std::vector<cv::DMatch> > matches;
-    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+        const int knn = 2;
 
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-    int badCount = 0;
-    for (size_t i = 0; i < matches.size(); i++)
-    {
-        if ((int)matches[i].size() != knn)
-            badCount++;
-        else
-        {
-            int localBadCount = 0;
-            for (int k = 0; k < knn; k++)
-            {
-                cv::DMatch match = matches[i][k];
-                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                    localBadCount++;
-            }
-            badCount += localBadCount > 0 ? 1 : 0;
-        }
-    }
-
-    ASSERT_EQ(0, badCount);
-}
-
-TEST_P(BruteForceMatcher, KnnMatch_3_Single)
-{
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const int knn = 3;
-
-    cv::gpu::GpuMat mask;
-    if (useMask)
-    {
-        mask.create(query.rows, train.rows, CV_8UC1);
-        mask.setTo(cv::Scalar::all(1));
-    }
-
-    std::vector< std::vector<cv::DMatch> > matches;
-    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
-
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-    int badCount = 0;
-    for (size_t i = 0; i < matches.size(); i++)
-    {
-        if ((int)matches[i].size() != knn)
-            badCount++;
-        else
-        {
-            int localBadCount = 0;
-            for (int k = 0; k < knn; k++)
-            {
-                cv::DMatch match = matches[i][k];
-                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                    localBadCount++;
-            }
-            badCount += localBadCount > 0 ? 1 : 0;
-        }
-    }
-
-    ASSERT_EQ(0, badCount);
-}
-
-TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
-{
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const int knn = 2;
-
-    cv::gpu::GpuMat d_train(train);
-
-    // make add() twice to test such case
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-    // prepare masks (make first nearest match illegal)
-    std::vector<cv::gpu::GpuMat> masks(2);
-    for (int mi = 0; mi < 2; mi++ )
-    {
-        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-        for (int di = 0; di < queryDescCount / 2; di++)
-            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-    }
-
-    std::vector< std::vector<cv::DMatch> > matches;
-
-    if (useMask)
-        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-    else
-        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
-
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-    int badCount = 0;
-    int shift = useMask ? 1 : 0;
-    for (size_t i = 0; i < matches.size(); i++)
-    {
-        if ((int)matches[i].size() != knn)
-            badCount++;
-        else
-        {
-            int localBadCount = 0;
-            for (int k = 0; k < knn; k++)
-            {
-                cv::DMatch match = matches[i][k];
-                {
-                    if ((int)i < queryDescCount / 2)
-                    {
-                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                            localBadCount++;
-                    }
-                    else
-                    {
-                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                            localBadCount++;
-                    }
-                }
-            }
-            badCount += localBadCount > 0 ? 1 : 0;
-        }
-    }
-
-    ASSERT_EQ(0, badCount);
-}
-
-TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
-{
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const int knn = 3;
-
-    cv::gpu::GpuMat d_train(train);
-
-    // make add() twice to test such case
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-    // prepare masks (make first nearest match illegal)
-    std::vector<cv::gpu::GpuMat> masks(2);
-    for (int mi = 0; mi < 2; mi++ )
-    {
-        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-        for (int di = 0; di < queryDescCount / 2; di++)
-            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-    }
-
-    std::vector< std::vector<cv::DMatch> > matches;
-
-    if (useMask)
-        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-    else
-        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
-
-    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-    int badCount = 0;
-    int shift = useMask ? 1 : 0;
-    for (size_t i = 0; i < matches.size(); i++)
-    {
-        if ((int)matches[i].size() != knn)
-            badCount++;
-        else
-        {
-            int localBadCount = 0;
-            for (int k = 0; k < knn; k++)
-            {
-                cv::DMatch match = matches[i][k];
-                {
-                    if ((int)i < queryDescCount / 2)
-                    {
-                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                            localBadCount++;
-                    }
-                    else
-                    {
-                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                            localBadCount++;
-                    }
-                }
-            }
-            badCount += localBadCount > 0 ? 1 : 0;
-        }
-    }
-
-    ASSERT_EQ(0, badCount);
-}
-
-TEST_P(BruteForceMatcher, RadiusMatch_Single)
-{
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const float radius = 1.f / countFactor;
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            std::vector< std::vector<cv::DMatch> > matches;
-            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
-    {
         cv::gpu::GpuMat mask;
         if (useMask)
         {
@@ -879,63 +644,305 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single)
         }
 
         std::vector< std::vector<cv::DMatch> > matches;
-        matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
+        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
 
         ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
         int badCount = 0;
         for (size_t i = 0; i < matches.size(); i++)
         {
-            if ((int)matches[i].size() != 1)
+            if ((int)matches[i].size() != knn)
                 badCount++;
             else
             {
-                cv::DMatch match = matches[i][0];
-                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
-                    badCount++;
+                int localBadCount = 0;
+                for (int k = 0; k < knn; k++)
+                {
+                    cv::DMatch match = matches[i][k];
+                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                        localBadCount++;
+                }
+                badCount += localBadCount > 0 ? 1 : 0;
             }
         }
 
         ASSERT_EQ(0, badCount);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
+}
+
+TEST_P(BruteForceMatcher, KnnMatch_3_Single)
+{
+    try
+    {
+        cv::gpu::BFMatcher_GPU matcher(normCode);
+
+        const int knn = 3;
+
+        cv::gpu::GpuMat mask;
+        if (useMask)
+        {
+            mask.create(query.rows, train.rows, CV_8UC1);
+            mask.setTo(cv::Scalar::all(1));
+        }
+
+        std::vector< std::vector<cv::DMatch> > matches;
+        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+        int badCount = 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            if ((int)matches[i].size() != knn)
+                badCount++;
+            else
+            {
+                int localBadCount = 0;
+                for (int k = 0; k < knn; k++)
+                {
+                    cv::DMatch match = matches[i][k];
+                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                        localBadCount++;
+                }
+                badCount += localBadCount > 0 ? 1 : 0;
+            }
+        }
+
+        ASSERT_EQ(0, badCount);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
+}
+
+TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
+{
+    try
+    {
+        cv::gpu::BFMatcher_GPU matcher(normCode);
+
+        const int knn = 2;
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++ )
+        {
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount / 2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+        }
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        if (useMask)
+            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+        else
+            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+        int badCount = 0;
+        int shift = useMask ? 1 : 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            if ((int)matches[i].size() != knn)
+                badCount++;
+            else
+            {
+                int localBadCount = 0;
+                for (int k = 0; k < knn; k++)
+                {
+                    cv::DMatch match = matches[i][k];
+                    {
+                        if ((int)i < queryDescCount / 2)
+                        {
+                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                                localBadCount++;
+                        }
+                        else
+                        {
+                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                                localBadCount++;
+                        }
+                    }
+                }
+                badCount += localBadCount > 0 ? 1 : 0;
+            }
+        }
+
+        ASSERT_EQ(0, badCount);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
+}
+
+TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
+{
+    try
+    {
+        cv::gpu::BFMatcher_GPU matcher(normCode);
+
+        const int knn = 3;
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++ )
+        {
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount / 2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+        }
+
+        std::vector< std::vector<cv::DMatch> > matches;
+
+        if (useMask)
+            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+        else
+            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+
+        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+        int badCount = 0;
+        int shift = useMask ? 1 : 0;
+        for (size_t i = 0; i < matches.size(); i++)
+        {
+            if ((int)matches[i].size() != knn)
+                badCount++;
+            else
+            {
+                int localBadCount = 0;
+                for (int k = 0; k < knn; k++)
+                {
+                    cv::DMatch match = matches[i][k];
+                    {
+                        if ((int)i < queryDescCount / 2)
+                        {
+                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                                localBadCount++;
+                        }
+                        else
+                        {
+                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                                localBadCount++;
+                        }
+                    }
+                }
+                badCount += localBadCount > 0 ? 1 : 0;
+            }
+        }
+
+        ASSERT_EQ(0, badCount);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
+}
+
+TEST_P(BruteForceMatcher, RadiusMatch_Single)
+{
+    try
+    {
+        cv::gpu::BFMatcher_GPU matcher(normCode);
+
+        const float radius = 1.f / countFactor;
+
+        if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+        {
+            try
+            {
+                std::vector< std::vector<cv::DMatch> > matches;
+                matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsNotImplemented, e.code);
+            }
+        }
+        else
+        {
+            cv::gpu::GpuMat mask;
+            if (useMask)
+            {
+                mask.create(query.rows, train.rows, CV_8UC1);
+                mask.setTo(cv::Scalar::all(1));
+            }
+
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
+
+            ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+            int badCount = 0;
+            for (size_t i = 0; i < matches.size(); i++)
+            {
+                if ((int)matches[i].size() != 1)
+                    badCount++;
+                else
+                {
+                    cv::DMatch match = matches[i][0];
+                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
+                        badCount++;
+                }
+            }
+
+            ASSERT_EQ(0, badCount);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
-    cv::gpu::BFMatcher_GPU matcher(normCode);
-
-    const int n = 3;
-    const float radius = 1.f / countFactor * n;
-
-    cv::gpu::GpuMat d_train(train);
-
-    // make add() twice to test such case
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-    // prepare masks (make first nearest match illegal)
-    std::vector<cv::gpu::GpuMat> masks(2);
-    for (int mi = 0; mi < 2; mi++)
+    try
     {
-        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-        for (int di = 0; di < queryDescCount / 2; di++)
-            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-    }
+        cv::gpu::BFMatcher_GPU matcher(normCode);
 
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
+        const int n = 3;
+        const float radius = 1.f / countFactor * n;
+
+        cv::gpu::GpuMat d_train(train);
+
+        // make add() twice to test such case
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+        // prepare masks (make first nearest match illegal)
+        std::vector<cv::gpu::GpuMat> masks(2);
+        for (int mi = 0; mi < 2; mi++)
         {
-            std::vector< std::vector<cv::DMatch> > matches;
-            matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
+            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+            for (int di = 0; di < queryDescCount / 2; di++)
+                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
         }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
-    {
+
         std::vector< std::vector<cv::DMatch> > matches;
 
         if (useMask)
@@ -977,6 +984,11 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 
         ASSERT_EQ(0, badCount);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 92d6fc002..4bdda9124 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -88,15 +88,23 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
 
 TEST_P(Blur, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
 
-    cv::Mat dst_gold;
-    cv::blur(src, dst_gold, ksize, anchor);
+        cv::Mat dst_gold;
+        cv::blur(src, dst_gold, ksize, anchor);
 
-    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
+        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
@@ -150,15 +158,23 @@ TEST_P(Sobel, Accuracy)
     if (dx == 0 && dy == 0)
         return;
 
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
 
-    cv::Mat dst_gold;
-    cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
+        cv::Mat dst_gold;
+        cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
@@ -213,15 +229,23 @@ TEST_P(Scharr, Accuracy)
     if (dx + dy != 1)
         return;
 
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
 
-    cv::Mat dst_gold;
-    cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
+        cv::Mat dst_gold;
+        cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
@@ -270,31 +294,39 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
 
 TEST_P(GaussianBlur, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    double sigma1 = randomDouble(0.1, 1.0);
-    double sigma2 = randomDouble(0.1, 1.0);
-
-    if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, type);
+        double sigma1 = randomDouble(0.1, 1.0);
+        double sigma2 = randomDouble(0.1, 1.0);
+
+        if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
         {
-            cv::gpu::GpuMat dst;
-            cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
+            try
+            {
+                cv::gpu::GpuMat dst;
+                cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsNotImplemented, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
+            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+            cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
+
+            cv::Mat dst_gold;
+            cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
-
-        cv::Mat dst_gold;
-        cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -349,15 +381,23 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
 
 TEST_P(Laplacian, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
 
-    cv::Mat dst_gold;
-    cv::Laplacian(src, dst_gold, -1, ksize.width);
+        cv::Mat dst_gold;
+        cv::Laplacian(src, dst_gold, -1, ksize.width);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
@@ -396,18 +436,26 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
 
 TEST_P(Erode, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-    cv::Mat dst_gold;
-    cv::erode(src, dst_gold, kernel, anchor, iterations);
+        cv::Mat dst_gold;
+        cv::erode(src, dst_gold, kernel, anchor, iterations);
 
-    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
+        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
@@ -445,18 +493,26 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
 
 TEST_P(Dilate, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-    cv::Mat dst_gold;
-    cv::dilate(src, dst_gold, kernel, anchor, iterations);
+        cv::Mat dst_gold;
+        cv::dilate(src, dst_gold, kernel, anchor, iterations);
 
-    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
+        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
@@ -499,18 +555,26 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
 
 TEST_P(MorphEx, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
 
-    cv::Mat dst_gold;
-    cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
+        cv::Mat dst_gold;
+        cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
 
-    cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
+        cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
 
-    EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
+        EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
@@ -553,16 +617,24 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
 
 TEST_P(Filter2D, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
 
-    cv::Mat dst_gold;
-    cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
+        cv::Mat dst_gold;
+        cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
diff --git a/modules/gpu/test/test_global_motion.cpp b/modules/gpu/test/test_global_motion.cpp
index b37d08068..2b5eab894 100644
--- a/modules/gpu/test/test_global_motion.cpp
+++ b/modules/gpu/test/test_global_motion.cpp
@@ -53,35 +53,43 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
 
 TEST_P(CompactPoints, CanCompactizeSmallInput)
 {
-    Mat src0(1, 3, CV_32FC2);
-    src0.at<Point2f>(0,0) = Point2f(0,0);
-    src0.at<Point2f>(0,1) = Point2f(0,1);
-    src0.at<Point2f>(0,2) = Point2f(0,2);
+    try
+    {
+        Mat src0(1, 3, CV_32FC2);
+        src0.at<Point2f>(0,0) = Point2f(0,0);
+        src0.at<Point2f>(0,1) = Point2f(0,1);
+        src0.at<Point2f>(0,2) = Point2f(0,2);
 
-    Mat src1(1, 3, CV_32FC2);
-    src1.at<Point2f>(0,0) = Point2f(1,0);
-    src1.at<Point2f>(0,1) = Point2f(1,1);
-    src1.at<Point2f>(0,2) = Point2f(1,2);
+        Mat src1(1, 3, CV_32FC2);
+        src1.at<Point2f>(0,0) = Point2f(1,0);
+        src1.at<Point2f>(0,1) = Point2f(1,1);
+        src1.at<Point2f>(0,2) = Point2f(1,2);
 
-    Mat mask(1, 3, CV_8U);
-    mask.at<uchar>(0,0) = 1;
-    mask.at<uchar>(0,1) = 0;
-    mask.at<uchar>(0,2) = 1;
+        Mat mask(1, 3, CV_8U);
+        mask.at<uchar>(0,0) = 1;
+        mask.at<uchar>(0,1) = 0;
+        mask.at<uchar>(0,2) = 1;
 
-    gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
-    gpu::compactPoints(dsrc0, dsrc1, dmask);
+        gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
+        gpu::compactPoints(dsrc0, dsrc1, dmask);
 
-    dsrc0.download(src0);
-    dsrc1.download(src1);
+        dsrc0.download(src0);
+        dsrc1.download(src1);
 
-    ASSERT_EQ(2, src0.cols);
-    ASSERT_EQ(2, src1.cols);
+        ASSERT_EQ(2, src0.cols);
+        ASSERT_EQ(2, src1.cols);
 
-    ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
-    ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
+        ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
+        ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
 
-    ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
-    ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
+        ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
+        ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp
index 9d7e545de..fed954053 100644
--- a/modules/gpu/test/test_gpumat.cpp
+++ b/modules/gpu/test/test_gpumat.cpp
@@ -69,90 +69,122 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(SetTo, Zero)
 {
-    cv::Scalar zero = cv::Scalar::all(0);
+    try
+    {
+        cv::Scalar zero = cv::Scalar::all(0);
 
-    cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-    mat.setTo(zero);
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(zero);
 
-    EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
+        EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(SetTo, SameVal)
 {
-    cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
-
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
+
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+                mat.setTo(val);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+
+            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-        mat.setTo(val);
-
-        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(SetTo, DifferentVal)
 {
-    cv::Scalar val = randomScalar(0.0, 255.0);
-
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Scalar val = randomScalar(0.0, 255.0);
+
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        {
+            try
+            {
+                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+                mat.setTo(val);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
+        }
+        else
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+
+            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-        mat.setTo(val);
-
-        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(SetTo, Masked)
 {
-    cv::Scalar val = randomScalar(0.0, 255.0);
-    cv::Mat mat_gold = randomMat(size, type);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Scalar val = randomScalar(0.0, 255.0);
+        cv::Mat mat_gold = randomMat(size, type);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-            mat.setTo(val, loadMat(mask));
+            try
+            {
+                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+                mat.setTo(val, loadMat(mask));
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
+            mat.setTo(val, loadMat(mask, useRoi));
+
+            mat_gold.setTo(val, mask);
+
+            EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
-        mat.setTo(val, loadMat(mask, useRoi));
-
-        mat_gold.setTo(val, mask);
-
-        EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -186,43 +218,59 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(CopyTo, WithOutMask)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    d_src.copyTo(dst);
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        d_src.copyTo(dst);
 
-    EXPECT_MAT_NEAR(src, dst, 0.0);
+        EXPECT_MAT_NEAR(src, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(CopyTo, Masked)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, type);
+        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat d_src = loadMat(src);
-            cv::gpu::GpuMat dst;
-            d_src.copyTo(dst, loadMat(mask, useRoi));
+            try
+            {
+                cv::gpu::GpuMat d_src = loadMat(src);
+                cv::gpu::GpuMat dst;
+                d_src.copyTo(dst, loadMat(mask, useRoi));
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+            cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+            d_src.copyTo(dst, loadMat(mask, useRoi));
+
+            cv::Mat dst_gold = cv::Mat::zeros(size, type);
+            src.copyTo(dst_gold, mask);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
-        d_src.copyTo(dst, loadMat(mask, useRoi));
-
-        cv::Mat dst_gold = cv::Mat::zeros(size, type);
-        src.copyTo(dst_gold, mask);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -257,63 +305,79 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
 
 TEST_P(ConvertTo, WithOutScaling)
 {
-    cv::Mat src = randomMat(size, depth1);
-
-    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth1);
+
+        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat d_src = loadMat(src);
-            cv::gpu::GpuMat dst;
-            d_src.convertTo(dst, depth2);
+            try
+            {
+                cv::gpu::GpuMat d_src = loadMat(src);
+                cv::gpu::GpuMat dst;
+                d_src.convertTo(dst, depth2);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+            d_src.convertTo(dst, depth2);
+
+            cv::Mat dst_gold;
+            src.convertTo(dst_gold, depth2);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
-        d_src.convertTo(dst, depth2);
-
-        cv::Mat dst_gold;
-        src.convertTo(dst_gold, depth2);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
 TEST_P(ConvertTo, WithScaling)
 {
-    cv::Mat src = randomMat(size, depth1);
-    double a = randomDouble(0.0, 1.0);
-    double b = randomDouble(-10.0, 10.0);
-
-    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    try
     {
-        try
+        cv::Mat src = randomMat(size, depth1);
+        double a = randomDouble(0.0, 1.0);
+        double b = randomDouble(-10.0, 10.0);
+
+        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
         {
-            cv::gpu::GpuMat d_src = loadMat(src);
-            cv::gpu::GpuMat dst;
-            d_src.convertTo(dst, depth2, a, b);
+            try
+            {
+                cv::gpu::GpuMat d_src = loadMat(src);
+                cv::gpu::GpuMat dst;
+                d_src.convertTo(dst, depth2, a, b);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+            d_src.convertTo(dst, depth2, a, b);
+
+            cv::Mat dst_gold;
+            src.convertTo(dst_gold, depth2, a, b);
+
+            EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
-        d_src.convertTo(dst, depth2, a, b);
-
-        cv::Mat dst_gold;
-        src.convertTo(dst_gold, depth2, a, b);
-
-        EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -338,22 +402,30 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(EnsureSizeIsEnough, BufferReuse)
 {
-    cv::gpu::GpuMat buffer(100, 100, CV_8U);
-    cv::gpu::GpuMat old = buffer;
+    try
+    {
+        cv::gpu::GpuMat buffer(100, 100, CV_8U);
+        cv::gpu::GpuMat old = buffer;
 
-    // don't reallocate memory
-    cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
-    EXPECT_EQ(10, buffer.rows);
-    EXPECT_EQ(20, buffer.cols);
-    EXPECT_EQ(CV_8UC1, buffer.type());
-    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+        // don't reallocate memory
+        cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
+        EXPECT_EQ(10, buffer.rows);
+        EXPECT_EQ(20, buffer.cols);
+        EXPECT_EQ(CV_8UC1, buffer.type());
+        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
 
-    // don't reallocate memory
-    cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
-    EXPECT_EQ(20, buffer.rows);
-    EXPECT_EQ(30, buffer.cols);
-    EXPECT_EQ(CV_8UC1, buffer.type());
-    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+        // don't reallocate memory
+        cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
+        EXPECT_EQ(20, buffer.rows);
+        EXPECT_EQ(30, buffer.cols);
+        EXPECT_EQ(CV_8UC1, buffer.type());
+        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp
index e6cb4fa85..9c4a97470 100644
--- a/modules/gpu/test/test_hough.cpp
+++ b/modules/gpu/test/test_hough.cpp
@@ -81,28 +81,36 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughLines, Accuracy)
 {
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const bool useRoi = GET_PARAM(2);
+    try
+    {
+        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+        const cv::Size size = GET_PARAM(1);
+        const bool useRoi = GET_PARAM(2);
 
-    const float rho = 1.0f;
-    const float theta = 1.5f * CV_PI / 180.0f;
-    const int threshold = 100;
+        const float rho = 1.0f;
+        const float theta = 1.5f * CV_PI / 180.0f;
+        const int threshold = 100;
 
-    cv::Mat src(size, CV_8UC1);
-    generateLines(src);
+        cv::Mat src(size, CV_8UC1);
+        generateLines(src);
 
-    cv::gpu::GpuMat d_lines;
-    cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
 
-    std::vector<cv::Vec2f> lines;
-    cv::gpu::HoughLinesDownload(d_lines, lines);
+        std::vector<cv::Vec2f> lines;
+        cv::gpu::HoughLinesDownload(d_lines, lines);
 
-    cv::Mat dst(size, CV_8UC1);
-    drawLines(dst, lines);
+        cv::Mat dst(size, CV_8UC1);
+        drawLines(dst, lines);
 
-    ASSERT_MAT_NEAR(src, dst, 0.0);
+        ASSERT_MAT_NEAR(src, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
@@ -126,53 +134,61 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughCircles, Accuracy)
 {
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const bool useRoi = GET_PARAM(2);
-
-    const float dp = 2.0f;
-    const float minDist = 10.0f;
-    const int minRadius = 10;
-    const int maxRadius = 20;
-    const int cannyThreshold = 100;
-    const int votesThreshold = 20;
-
-    std::vector<cv::Vec3f> circles_gold(4);
-    circles_gold[0] = cv::Vec3i(20, 20, minRadius);
-    circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
-    circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
-    circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
-
-    cv::Mat src(size, CV_8UC1);
-    drawCircles(src, circles_gold, true);
-
-    cv::gpu::GpuMat d_circles;
-    cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-
-    std::vector<cv::Vec3f> circles;
-    cv::gpu::HoughCirclesDownload(d_circles, circles);
-
-    ASSERT_FALSE(circles.empty());
-
-    for (size_t i = 0; i < circles.size(); ++i)
+    try
     {
-        cv::Vec3f cur = circles[i];
+        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+        const cv::Size size = GET_PARAM(1);
+        const bool useRoi = GET_PARAM(2);
 
-        bool found = false;
+        const float dp = 2.0f;
+        const float minDist = 10.0f;
+        const int minRadius = 10;
+        const int maxRadius = 20;
+        const int cannyThreshold = 100;
+        const int votesThreshold = 20;
 
-        for (size_t j = 0; j < circles_gold.size(); ++j)
+        std::vector<cv::Vec3f> circles_gold(4);
+        circles_gold[0] = cv::Vec3i(20, 20, minRadius);
+        circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
+        circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
+        circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
+
+        cv::Mat src(size, CV_8UC1);
+        drawCircles(src, circles_gold, true);
+
+        cv::gpu::GpuMat d_circles;
+        cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+
+        std::vector<cv::Vec3f> circles;
+        cv::gpu::HoughCirclesDownload(d_circles, circles);
+
+        ASSERT_FALSE(circles.empty());
+
+        for (size_t i = 0; i < circles.size(); ++i)
         {
-            cv::Vec3f gold = circles_gold[j];
+            cv::Vec3f cur = circles[i];
 
-            if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
+            bool found = false;
+
+            for (size_t j = 0; j < circles_gold.size(); ++j)
             {
-                found = true;
-                break;
-            }
-        }
+                cv::Vec3f gold = circles_gold[j];
 
-        ASSERT_TRUE(found);
+                if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            ASSERT_TRUE(found);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -190,60 +206,68 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(GeneralizedHough, POSITION)
 {
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const bool useRoi = GET_PARAM(1);
-
-    cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(templ.empty());
-
-    cv::Point templCenter(templ.cols / 2, templ.rows / 2);
-
-    const size_t gold_count = 3;
-    cv::Point pos_gold[gold_count];
-    pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
-    pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
-    pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
-
-    cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
-    for (size_t i = 0; i < gold_count; ++i)
+    try
     {
-        cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
-        cv::Mat imageROI = image(rec);
-        templ.copyTo(imageROI);
-    }
+        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+        const bool useRoi = GET_PARAM(1);
 
-    cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
-    hough->set("votesThreshold", 200);
+        cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(templ.empty());
 
-    hough->setTemplate(loadMat(templ, useRoi));
+        cv::Point templCenter(templ.cols / 2, templ.rows / 2);
 
-    cv::gpu::GpuMat d_pos;
-    hough->detect(loadMat(image, useRoi), d_pos);
+        const size_t gold_count = 3;
+        cv::Point pos_gold[gold_count];
+        pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
+        pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
+        pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
 
-    std::vector<cv::Vec4f> pos;
-    hough->download(d_pos, pos);
-
-    ASSERT_EQ(gold_count, pos.size());
-
-    for (size_t i = 0; i < gold_count; ++i)
-    {
-        cv::Point gold = pos_gold[i];
-
-        bool found = false;
-
-        for (size_t j = 0; j < pos.size(); ++j)
+        cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
+        for (size_t i = 0; i < gold_count; ++i)
         {
-            cv::Point2f p(pos[j][0], pos[j][1]);
-
-            if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
-            {
-                found = true;
-                break;
-            }
+            cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
+            cv::Mat imageROI = image(rec);
+            templ.copyTo(imageROI);
         }
 
-        ASSERT_TRUE(found);
+        cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
+        hough->set("votesThreshold", 200);
+
+        hough->setTemplate(loadMat(templ, useRoi));
+
+        cv::gpu::GpuMat d_pos;
+        hough->detect(loadMat(image, useRoi), d_pos);
+
+        std::vector<cv::Vec4f> pos;
+        hough->download(d_pos, pos);
+
+        ASSERT_EQ(gold_count, pos.size());
+
+        for (size_t i = 0; i < gold_count; ++i)
+        {
+            cv::Point gold = pos_gold[i];
+
+            bool found = false;
+
+            for (size_t j = 0; j < pos.size(); ++j)
+            {
+                cv::Point2f p(pos[j][0], pos[j][1]);
+
+                if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
+                {
+                    found = true;
+                    break;
+                }
+            }
+
+            ASSERT_TRUE(found);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index 71d4a8e65..9de380810 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -66,15 +66,23 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Integral, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_8UC1);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_8UC1);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
-    cv::gpu::integral(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
+        cv::gpu::integral(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::integral(src, dst_gold, CV_32S);
+        cv::Mat dst_gold;
+        cv::integral(src, dst_gold, CV_32S);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
@@ -99,32 +107,40 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(HistEven, Accuracy)
 {
-    cv::Mat img = readImage("stereobm/aloe-L.png");
-    ASSERT_FALSE(img.empty());
+    try
+    {
+        cv::Mat img = readImage("stereobm/aloe-L.png");
+        ASSERT_FALSE(img.empty());
 
-    cv::Mat hsv;
-    cv::cvtColor(img, hsv, CV_BGR2HSV);
+        cv::Mat hsv;
+        cv::cvtColor(img, hsv, CV_BGR2HSV);
 
-    int hbins = 30;
-    float hranges[] = {0.0f, 180.0f};
+        int hbins = 30;
+        float hranges[] = {0.0f, 180.0f};
 
-    std::vector<cv::gpu::GpuMat> srcs;
-    cv::gpu::split(loadMat(hsv), srcs);
+        std::vector<cv::gpu::GpuMat> srcs;
+        cv::gpu::split(loadMat(hsv), srcs);
 
-    cv::gpu::GpuMat hist;
-    cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
+        cv::gpu::GpuMat hist;
+        cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
 
-    cv::MatND histnd;
-    int histSize[] = {hbins};
-    const float* ranges[] = {hranges};
-    int channels[] = {0};
-    cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
+        cv::MatND histnd;
+        int histSize[] = {hbins};
+        const float* ranges[] = {hranges};
+        int channels[] = {0};
+        cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
 
-    cv::Mat hist_gold = histnd;
-    hist_gold = hist_gold.t();
-    hist_gold.convertTo(hist_gold, CV_32S);
+        cv::Mat hist_gold = histnd;
+        hist_gold = hist_gold.t();
+        hist_gold.convertTo(hist_gold, CV_32S);
 
-    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@@ -164,15 +180,23 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(CalcHist, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_8UC1);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_8UC1);
 
-    cv::gpu::GpuMat hist;
-    cv::gpu::calcHist(loadMat(src), hist);
+        cv::gpu::GpuMat hist;
+        cv::gpu::calcHist(loadMat(src), hist);
 
-    cv::Mat hist_gold;
-    calcHistGold(src, hist_gold);
+        cv::Mat hist_gold;
+        calcHistGold(src, hist_gold);
 
-    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
@@ -198,15 +222,23 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(EqualizeHist, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_8UC1);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_8UC1);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::equalizeHist(loadMat(src), dst);
+        cv::gpu::GpuMat dst;
+        cv::gpu::equalizeHist(loadMat(src), dst);
 
-    cv::Mat dst_gold;
-    cv::equalizeHist(src, dst_gold);
+        cv::Mat dst_gold;
+        cv::equalizeHist(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
@@ -232,28 +264,36 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(ColumnSum, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_32FC1);
-
-    cv::gpu::GpuMat d_dst;
-    cv::gpu::columnSum(loadMat(src), d_dst);
-
-    cv::Mat dst(d_dst);
-
-    for (int j = 0; j < src.cols; ++j)
+    try
     {
-        float gold = src.at<float>(0, j);
-        float res = dst.at<float>(0, j);
-        ASSERT_NEAR(res, gold, 1e-5);
-    }
+        cv::Mat src = randomMat(size, CV_32FC1);
+
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::columnSum(loadMat(src), d_dst);
+
+        cv::Mat dst(d_dst);
 
-    for (int i = 1; i < src.rows; ++i)
-    {
         for (int j = 0; j < src.cols; ++j)
         {
-            float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
-            float res = dst.at<float>(i, j);
+            float gold = src.at<float>(0, j);
+            float res = dst.at<float>(0, j);
             ASSERT_NEAR(res, gold, 1e-5);
         }
+
+        for (int i = 1; i < src.rows; ++i)
+        {
+            for (int j = 0; j < src.cols; ++j)
+            {
+                float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
+                float res = dst.at<float>(i, j);
+                ASSERT_NEAR(res, gold, 1e-5);
+            }
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -287,33 +327,41 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
 
 TEST_P(Canny, Accuracy)
 {
-    cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(img.empty());
-
-    double low_thresh = 50.0;
-    double high_thresh = 100.0;
-
-    if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+    try
     {
-        try
+        cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(img.empty());
+
+        double low_thresh = 50.0;
+        double high_thresh = 100.0;
+
+        if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
         {
-        cv::gpu::GpuMat edges;
-        cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+            try
+            {
+            cv::gpu::GpuMat edges;
+            cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+            }
+            catch (const cv::Exception& e)
+            {
+                ASSERT_EQ(CV_StsNotImplemented, e.code);
+            }
         }
-        catch (const cv::Exception& e)
+        else
         {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
+            cv::gpu::GpuMat edges;
+            cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+            cv::Mat edges_gold;
+            cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+            EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
         }
     }
-    else
+    catch (...)
     {
-        cv::gpu::GpuMat edges;
-        cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-        cv::Mat edges_gold;
-        cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-        EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -351,50 +399,66 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(MeanShift, Filtering)
 {
-    cv::Mat img_template;
-    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-        img_template = readImage("meanshift/con_result.png");
-    else
-        img_template = readImage("meanshift/con_result_CC1X.png");
-    ASSERT_FALSE(img_template.empty());
+    try
+    {
+        cv::Mat img_template;
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            img_template = readImage("meanshift/con_result.png");
+        else
+            img_template = readImage("meanshift/con_result_CC1X.png");
+        ASSERT_FALSE(img_template.empty());
 
-    cv::gpu::GpuMat d_dst;
-    cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
 
-    ASSERT_EQ(CV_8UC4, d_dst.type());
+        ASSERT_EQ(CV_8UC4, d_dst.type());
 
-    cv::Mat dst(d_dst);
+        cv::Mat dst(d_dst);
 
-    cv::Mat result;
-    cv::cvtColor(dst, result, CV_BGRA2BGR);
+        cv::Mat result;
+        cv::cvtColor(dst, result, CV_BGRA2BGR);
 
-    EXPECT_MAT_NEAR(img_template, result, 0.0);
+        EXPECT_MAT_NEAR(img_template, result, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(MeanShift, Proc)
 {
-    cv::FileStorage fs;
-    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
-    else
-        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+    try
+    {
+        cv::FileStorage fs;
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+        else
+            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
 
-    cv::Mat spmap_template;
-    fs["spmap"] >> spmap_template;
-    ASSERT_FALSE(spmap_template.empty());
+        cv::Mat spmap_template;
+        fs["spmap"] >> spmap_template;
+        ASSERT_FALSE(spmap_template.empty());
 
-    cv::gpu::GpuMat rmap_filtered;
-    cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
+        cv::gpu::GpuMat rmap_filtered;
+        cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
 
-    cv::gpu::GpuMat rmap;
-    cv::gpu::GpuMat spmap;
-    cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
+        cv::gpu::GpuMat rmap;
+        cv::gpu::GpuMat spmap;
+        cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
 
-    ASSERT_EQ(CV_8UC4, rmap.type());
+        ASSERT_EQ(CV_8UC4, rmap.type());
 
-    EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
-    EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
+        EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
+        EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
@@ -420,25 +484,33 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
 
 TEST_P(MeanShiftSegmentation, Regression)
 {
-    cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
-    ASSERT_FALSE(img.empty());
+    try
+    {
+        cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
+        ASSERT_FALSE(img.empty());
 
-    std::ostringstream path;
-    path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
-    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-        path << ".png";
-    else
-        path << "_CC1X.png";
-    cv::Mat dst_gold = readImage(path.str());
-    ASSERT_FALSE(dst_gold.empty());
+        std::ostringstream path;
+        path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+            path << ".png";
+        else
+            path << "_CC1X.png";
+        cv::Mat dst_gold = readImage(path.str());
+        ASSERT_FALSE(dst_gold.empty());
 
-    cv::Mat dst;
-    cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
+        cv::Mat dst;
+        cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
 
-    cv::Mat dst_rgb;
-    cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+        cv::Mat dst_rgb;
+        cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
 
-    EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
+        EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
@@ -492,23 +564,31 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Blend, Accuracy)
 {
-    int depth = CV_MAT_DEPTH(type);
+    try
+    {
+        int depth = CV_MAT_DEPTH(type);
 
-    cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-    cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-    cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
-    cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
+        cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+        cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+        cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
+        cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
 
-    cv::gpu::GpuMat result;
-    cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
+        cv::gpu::GpuMat result;
+        cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
 
-    cv::Mat result_gold;
-    if (depth == CV_8U)
-        blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
-    else
-        blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
+        cv::Mat result_gold;
+        if (depth == CV_8U)
+            blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
+        else
+            blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
 
-    EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
+        EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
@@ -582,16 +662,24 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
 
 TEST_P(Convolve, Accuracy)
 {
-    cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
-    cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
+    try
+    {
+        cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
+        cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+        cv::gpu::GpuMat dst;
+        cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
 
-    cv::Mat dst_gold;
-    convolveDFT(src, kernel, dst_gold, ccorr);
+        cv::Mat dst_gold;
+        convolveDFT(src, kernel, dst_gold, ccorr);
 
-    EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
+        EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
@@ -630,16 +718,24 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
 
 TEST_P(MatchTemplate8U, Accuracy)
 {
-    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
-    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
+    try
+    {
+        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
+        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+        cv::gpu::GpuMat dst;
+        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-    cv::Mat dst_gold;
-    cv::matchTemplate(image, templ, dst_gold, method);
+        cv::Mat dst_gold;
+        cv::matchTemplate(image, templ, dst_gold, method);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
+        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
@@ -676,16 +772,24 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
 
 TEST_P(MatchTemplate32F, Regression)
 {
-    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
-    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
+    try
+    {
+        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
+        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+        cv::gpu::GpuMat dst;
+        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-    cv::Mat dst_gold;
-    cv::matchTemplate(image, templ, dst_gold, method);
+        cv::Mat dst_gold;
+        cv::matchTemplate(image, templ, dst_gold, method);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
+        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
@@ -714,24 +818,32 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
 
 TEST_P(MatchTemplateBlackSource, Accuracy)
 {
-    cv::Mat image = readImage("matchtemplate/black.png");
-    ASSERT_FALSE(image.empty());
+    try
+    {
+        cv::Mat image = readImage("matchtemplate/black.png");
+        ASSERT_FALSE(image.empty());
 
-    cv::Mat pattern = readImage("matchtemplate/cat.png");
-    ASSERT_FALSE(pattern.empty());
+        cv::Mat pattern = readImage("matchtemplate/cat.png");
+        ASSERT_FALSE(pattern.empty());
 
-    cv::gpu::GpuMat d_dst;
-    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
 
-    cv::Mat dst(d_dst);
+        cv::Mat dst(d_dst);
 
-    double maxValue;
-    cv::Point maxLoc;
-    cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
+        double maxValue;
+        cv::Point maxLoc;
+        cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
 
-    cv::Point maxLocGold = cv::Point(284, 12);
+        cv::Point maxLocGold = cv::Point(284, 12);
 
-    ASSERT_EQ(maxLocGold, maxLoc);
+        ASSERT_EQ(maxLocGold, maxLoc);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
@@ -759,32 +871,40 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
 
 TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
 {
-    cv::Mat image = readImage(imageName);
-    ASSERT_FALSE(image.empty());
+    try
+    {
+        cv::Mat image = readImage(imageName);
+        ASSERT_FALSE(image.empty());
 
-    cv::Mat pattern = readImage(patternName);
-    ASSERT_FALSE(pattern.empty());
+        cv::Mat pattern = readImage(patternName);
+        ASSERT_FALSE(pattern.empty());
 
-    cv::gpu::GpuMat d_dst;
-    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
 
-    cv::Mat dst(d_dst);
+        cv::Mat dst(d_dst);
 
-    cv::Point minLoc, maxLoc;
-    double minVal, maxVal;
-    cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
+        cv::Point minLoc, maxLoc;
+        double minVal, maxVal;
+        cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
 
-    cv::Mat dstGold;
-    cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
+        cv::Mat dstGold;
+        cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
 
-    double minValGold, maxValGold;
-    cv::Point minLocGold, maxLocGold;
-    cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
+        double minValGold, maxValGold;
+        cv::Point minLocGold, maxLocGold;
+        cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
 
-    ASSERT_EQ(minLocGold, minLoc);
-    ASSERT_EQ(maxLocGold, maxLoc);
-    ASSERT_LE(maxVal, 1.0);
-    ASSERT_GE(minVal, -1.0);
+        ASSERT_EQ(minLocGold, minLoc);
+        ASSERT_EQ(maxLocGold, maxLoc);
+        ASSERT_LE(maxVal, 1.0);
+        ASSERT_GE(minVal, -1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
@@ -808,47 +928,63 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
 {
-    cv::Mat scene = readImage("matchtemplate/scene.png");
-    ASSERT_FALSE(scene.empty());
+    try
+    {
+        cv::Mat scene = readImage("matchtemplate/scene.png");
+        ASSERT_FALSE(scene.empty());
 
-    cv::Mat templ = readImage("matchtemplate/template.png");
-    ASSERT_FALSE(templ.empty());
+        cv::Mat templ = readImage("matchtemplate/template.png");
+        ASSERT_FALSE(templ.empty());
 
-    cv::gpu::GpuMat d_result;
-    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
+        cv::gpu::GpuMat d_result;
+        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
 
-    cv::Mat result(d_result);
+        cv::Mat result(d_result);
 
-    double minVal;
-    cv::Point minLoc;
-    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+        double minVal;
+        cv::Point minLoc;
+        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-    ASSERT_GE(minVal, 0);
-    ASSERT_LT(minVal, 1e-3);
-    ASSERT_EQ(344, minLoc.x);
-    ASSERT_EQ(0, minLoc.y);
+        ASSERT_GE(minVal, 0);
+        ASSERT_LT(minVal, 1e-3);
+        ASSERT_EQ(344, minLoc.x);
+        ASSERT_EQ(0, minLoc.y);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
 {
-    cv::Mat scene = readImage("matchtemplate/scene.png");
-    ASSERT_FALSE(scene.empty());
+    try
+    {
+        cv::Mat scene = readImage("matchtemplate/scene.png");
+        ASSERT_FALSE(scene.empty());
 
-    cv::Mat templ = readImage("matchtemplate/template.png");
-    ASSERT_FALSE(templ.empty());
+        cv::Mat templ = readImage("matchtemplate/template.png");
+        ASSERT_FALSE(templ.empty());
 
-    cv::gpu::GpuMat d_result;
-    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
+        cv::gpu::GpuMat d_result;
+        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
 
-    cv::Mat result(d_result);
+        cv::Mat result(d_result);
 
-    double minVal;
-    cv::Point minLoc;
-    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+        double minVal;
+        cv::Point minLoc;
+        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-    ASSERT_GE(minVal, 0);
-    ASSERT_EQ(344, minLoc.x);
-    ASSERT_EQ(0, minLoc.y);
+        ASSERT_GE(minVal, 0);
+        ASSERT_EQ(344, minLoc.x);
+        ASSERT_EQ(0, minLoc.y);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
@@ -881,27 +1017,43 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
 
 TEST_P(MulSpectrums, Simple)
 {
-    cv::gpu::GpuMat c;
-    cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
+    try
+    {
+        cv::gpu::GpuMat c;
+        cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
 
-    cv::Mat c_gold;
-    cv::mulSpectrums(a, b, c_gold, flag, false);
+        cv::Mat c_gold;
+        cv::mulSpectrums(a, b, c_gold, flag, false);
 
-    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(MulSpectrums, Scaled)
 {
-    float scale = 1.f / size.area();
+    try
+    {
+        float scale = 1.f / size.area();
 
-    cv::gpu::GpuMat c;
-    cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
+        cv::gpu::GpuMat c;
+        cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
 
-    cv::Mat c_gold;
-    cv::mulSpectrums(a, b, c_gold, flag, false);
-    c_gold.convertTo(c_gold, c_gold.type(), scale);
+        cv::Mat c_gold;
+        cv::mulSpectrums(a, b, c_gold, flag, false);
+        c_gold.convertTo(c_gold, c_gold.type(), scale);
 
-    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
@@ -950,26 +1102,34 @@ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplac
 
 TEST_P(Dft, C2C)
 {
-    int cols = randomInt(2, 100);
-    int rows = randomInt(2, 100);
-
-    for (int i = 0; i < 2; ++i)
+    try
     {
-        bool inplace = i != 0;
+        int cols = randomInt(2, 100);
+        int rows = randomInt(2, 100);
 
-        testC2C("no flags", cols, rows, 0, inplace);
-        testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
-        testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
-        testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
-        testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
-        testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
-        testC2C("single col", 1, rows, 0, inplace);
-        testC2C("single row", cols, 1, 0, inplace);
-        testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
-        testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
-        testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
-        testC2C("size 1 2", 1, 2, 0, inplace);
-        testC2C("size 2 1", 2, 1, 0, inplace);
+        for (int i = 0; i < 2; ++i)
+        {
+            bool inplace = i != 0;
+
+            testC2C("no flags", cols, rows, 0, inplace);
+            testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+            testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+            testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+            testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+            testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+            testC2C("single col", 1, rows, 0, inplace);
+            testC2C("single row", cols, 1, 0, inplace);
+            testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+            testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+            testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+            testC2C("size 1 2", 1, 2, 0, inplace);
+            testC2C("size 2 1", 2, 1, 0, inplace);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1011,24 +1171,32 @@ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
 
 TEST_P(Dft, R2CThenC2R)
 {
-    int cols = randomInt(2, 100);
-    int rows = randomInt(2, 100);
+    try
+    {
+        int cols = randomInt(2, 100);
+        int rows = randomInt(2, 100);
 
-    testR2CThenC2R("sanity", cols, rows, false);
-    testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
-    testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
-    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
-    testR2CThenC2R("single col", 1, rows, false);
-    testR2CThenC2R("single col 1", 1, rows + 1, false);
-    testR2CThenC2R("single row", cols, 1, false);
-    testR2CThenC2R("single row 1", cols + 1, 1, false);
+        testR2CThenC2R("sanity", cols, rows, false);
+        testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+        testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+        testR2CThenC2R("single col", 1, rows, false);
+        testR2CThenC2R("single col 1", 1, rows + 1, false);
+        testR2CThenC2R("single row", cols, 1, false);
+        testR2CThenC2R("single row 1", cols + 1, 1, false);
 
-    testR2CThenC2R("sanity", cols, rows, true);
-    testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
-    testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
-    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
-    testR2CThenC2R("single row", cols, 1, true);
-    testR2CThenC2R("single row 1", cols + 1, 1, true);
+        testR2CThenC2R("sanity", cols, rows, true);
+        testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+        testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+        testR2CThenC2R("single row", cols, 1, true);
+        testR2CThenC2R("single row 1", cols + 1, 1, true);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
@@ -1061,18 +1229,26 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
 
 TEST_P(CornerHarris, Accuracy)
 {
-    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-    ASSERT_FALSE(src.empty());
+    try
+    {
+        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+        ASSERT_FALSE(src.empty());
 
-    double k = randomDouble(0.1, 0.9);
+        double k = randomDouble(0.1, 0.9);
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
 
-    cv::Mat dst_gold;
-    cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
+        cv::Mat dst_gold;
+        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
@@ -1107,16 +1283,24 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
 
 TEST_P(CornerMinEigen, Accuracy)
 {
-    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-    ASSERT_FALSE(src.empty());
+    try
+    {
+        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+        ASSERT_FALSE(src.empty());
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
+        cv::gpu::GpuMat dst;
+        cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
 
-    cv::Mat dst_gold;
-    cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
+        cv::Mat dst_gold;
+        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
diff --git a/modules/gpu/test/test_labeling.cpp b/modules/gpu/test/test_labeling.cpp
index c56fc0ef8..f5e79cd46 100644
--- a/modules/gpu/test/test_labeling.cpp
+++ b/modules/gpu/test/test_labeling.cpp
@@ -168,27 +168,35 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(Labeling, ConnectedComponents)
 {
-    cv::Mat image;
-    cvtColor(loat_image(), image, CV_BGR2GRAY);
+    try
+    {
+        cv::Mat image;
+        cvtColor(loat_image(), image, CV_BGR2GRAY);
 
-    cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+        cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
 
-    ASSERT_TRUE(image.type() == CV_8UC1);
+        ASSERT_TRUE(image.type() == CV_8UC1);
 
-    GreedyLabeling host(image);
-    host(host._labels);
+        GreedyLabeling host(image);
+        host(host._labels);
 
-    cv::gpu::GpuMat mask;
-    mask.create(image.rows, image.cols, CV_8UC1);
+        cv::gpu::GpuMat mask;
+        mask.create(image.rows, image.cols, CV_8UC1);
 
-    cv::gpu::GpuMat components;
-    components.create(image.rows, image.cols, CV_32SC1);
+        cv::gpu::GpuMat components;
+        components.create(image.rows, image.cols, CV_32SC1);
 
-    cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
 
-    ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
 
-    host.checkCorrectness(cv::Mat(components));
+        host.checkCorrectness(cv::Mat(components));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);
diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp
index 484f3cfbb..0b844d35d 100644
--- a/modules/gpu/test/test_nvidia.cpp
+++ b/modules/gpu/test/test_nvidia.cpp
@@ -69,82 +69,169 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
 struct NPPST : NVidiaTest {};
 struct NCV : NVidiaTest {};
 
-//TEST_P(NPPST, Integral)
-//{
-//    bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
+TEST_P(NPPST, Integral)
+{
+    try
+    {
+        bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
 
-//    ASSERT_TRUE(res);
-//}
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
+}
 
 TEST_P(NPPST, SquaredIntegral)
 {
-    bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NPPST, RectStdDev)
 {
-    bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NPPST, Resize)
 {
-    bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NPPST, VectorOperations)
 {
-    bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NPPST, Transpose)
 {
-    bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NCV, VectorOperations)
 {
-    bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NCV, HaarCascadeLoader)
 {
-    bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NCV, HaarCascadeApplication)
 {
-    bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NCV, HypothesesFiltration)
 {
-    bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(NCV, Visualization)
 {
-    // this functionality doesn't used in gpu module
-    bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
+    try
+    {
+        bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
 
-    ASSERT_TRUE(res);
+        ASSERT_TRUE(res);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
diff --git a/modules/gpu/test/test_objdetect.cpp b/modules/gpu/test/test_objdetect.cpp
index 4fb295d4c..81c6c40ce 100644
--- a/modules/gpu/test/test_objdetect.cpp
+++ b/modules/gpu/test/test_objdetect.cpp
@@ -175,114 +175,129 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
     }
 };
 
-// desabled while resize does not fixed
-TEST_P(HOG, DISABLED_Detect)
+TEST_P(HOG, Detect)
 {
-    cv::Mat img_rgb = readImage("hog/road.png");
-    ASSERT_FALSE(img_rgb.empty());
+    try
+    {
+        cv::Mat img_rgb = readImage("hog/road.png");
+        ASSERT_FALSE(img_rgb.empty());
 
-#ifdef DUMP
-    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-    ASSERT_TRUE(f.is_open());
-#else
-    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-    ASSERT_TRUE(f.is_open());
-#endif
+    #ifdef DUMP
+        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+        ASSERT_TRUE(f.is_open());
+    #else
+        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+        ASSERT_TRUE(f.is_open());
+    #endif
 
-    // Test on color image
-    cv::Mat img;
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    testDetect(img);
+        // Test on color image
+        cv::Mat img;
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        testDetect(img);
 
-    // Test on gray image
-    cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
-    testDetect(img);
+        // Test on gray image
+        cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+        testDetect(img);
 
-    f.close();
+        f.close();
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(HOG, GetDescriptors)
 {
-    // Load image (e.g. train data, composed from windows)
-    cv::Mat img_rgb = readImage("hog/train_data.png");
-    ASSERT_FALSE(img_rgb.empty());
-
-    // Convert to C4
-    cv::Mat img;
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-
-    cv::gpu::GpuMat d_img(img);
-
-    // Convert train images into feature vectors (train table)
-    cv::gpu::GpuMat descriptors, descriptors_by_cols;
-    getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
-    getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
-
-    // Check size of the result train table
-    wins_per_img_x = 3;
-    wins_per_img_y = 2;
-    blocks_per_win_x = 7;
-    blocks_per_win_y = 15;
-    block_hist_size = 36;
-    cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
-                                            wins_per_img_x * wins_per_img_y);
-    ASSERT_EQ(descr_size_expected, descriptors.size());
-
-    // Check both formats of output descriptors are handled correctly
-    cv::Mat dr(descriptors);
-    cv::Mat dc(descriptors_by_cols);
-    for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
+    try
     {
-        const float* l = dr.rowRange(i, i + 1).ptr<float>();
-        const float* r = dc.rowRange(i, i + 1).ptr<float>();
-        for (int y = 0; y < blocks_per_win_y; ++y)
-            for (int x = 0; x < blocks_per_win_x; ++x)
-                for (int k = 0; k < block_hist_size; ++k)
-                    ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
-                              r[(x * blocks_per_win_y + y) * block_hist_size + k]);
+        // Load image (e.g. train data, composed from windows)
+        cv::Mat img_rgb = readImage("hog/train_data.png");
+        ASSERT_FALSE(img_rgb.empty());
+
+        // Convert to C4
+        cv::Mat img;
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+
+        cv::gpu::GpuMat d_img(img);
+
+        // Convert train images into feature vectors (train table)
+        cv::gpu::GpuMat descriptors, descriptors_by_cols;
+        getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
+        getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
+
+        // Check size of the result train table
+        wins_per_img_x = 3;
+        wins_per_img_y = 2;
+        blocks_per_win_x = 7;
+        blocks_per_win_y = 15;
+        block_hist_size = 36;
+        cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
+                                                wins_per_img_x * wins_per_img_y);
+        ASSERT_EQ(descr_size_expected, descriptors.size());
+
+        // Check both formats of output descriptors are handled correctly
+        cv::Mat dr(descriptors);
+        cv::Mat dc(descriptors_by_cols);
+        for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
+        {
+            const float* l = dr.rowRange(i, i + 1).ptr<float>();
+            const float* r = dc.rowRange(i, i + 1).ptr<float>();
+            for (int y = 0; y < blocks_per_win_y; ++y)
+                for (int x = 0; x < blocks_per_win_x; ++x)
+                    for (int k = 0; k < block_hist_size; ++k)
+                        ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
+                                  r[(x * blocks_per_win_y + y) * block_hist_size + k]);
+        }
+
+        /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
+        be defferent, due to border values interpolation. Using of many small images is slower, however we
+        wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
+        works good, it can be checked in the gpu_hog sample */
+
+        img_rgb = readImage("hog/positive1.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        // Everything is fine with interpolation for left top subimage
+        ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
+
+        img_rgb = readImage("hog/positive2.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
+
+        img_rgb = readImage("hog/negative1.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
+
+        img_rgb = readImage("hog/negative2.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
+
+        img_rgb = readImage("hog/positive3.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
+
+        img_rgb = readImage("hog/negative3.png");
+        ASSERT_TRUE(!img_rgb.empty());
+        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+        computeBlockHistograms(cv::gpu::GpuMat(img));
+        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
-    be defferent, due to border values interpolation. Using of many small images is slower, however we
-    wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
-    works good, it can be checked in the gpu_hog sample */
-
-    img_rgb = readImage("hog/positive1.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    // Everything is fine with interpolation for left top subimage
-    ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
-
-    img_rgb = readImage("hog/positive2.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
-
-    img_rgb = readImage("hog/negative1.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
-
-    img_rgb = readImage("hog/negative2.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
-
-    img_rgb = readImage("hog/positive3.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
-
-    img_rgb = readImage("hog/negative3.png");
-    ASSERT_TRUE(!img_rgb.empty());
-    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-    computeBlockHistograms(cv::gpu::GpuMat(img));
-    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
@@ -305,27 +320,35 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
 
 TEST_P(CalTech, HOG)
 {
-    cv::gpu::GpuMat d_img(img);
-    cv::Mat markedImage(img.clone());
-
-    cv::gpu::HOGDescriptor d_hog;
-    d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-    d_hog.nlevels = d_hog.nlevels + 32;
-
-    std::vector<cv::Rect> found_locations;
-    d_hog.detectMultiScale(d_img, found_locations);
-
-#if defined (LOG_CASCADE_STATISTIC)
-    for (int i = 0; i < (int)found_locations.size(); i++)
+    try
     {
-        cv::Rect r = found_locations[i];
+        cv::gpu::GpuMat d_img(img);
+        cv::Mat markedImage(img.clone());
 
-        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+        d_hog.nlevels = d_hog.nlevels + 32;
+
+        std::vector<cv::Rect> found_locations;
+        d_hog.detectMultiScale(d_img, found_locations);
+
+    #if defined (LOG_CASCADE_STATISTIC)
+        for (int i = 0; i < (int)found_locations.size(); i++)
+        {
+            cv::Rect r = found_locations[i];
+
+            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
+        }
+
+        cv::imshow("Res", markedImage); cv::waitKey();
+    #endif
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    cv::imshow("Res", markedImage); cv::waitKey();
-#endif
 }
 
 INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
@@ -352,9 +375,17 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_Read_classifier, Accuracy)
 {
-    cv::gpu::CascadeClassifier_GPU classifier;
-    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-    ASSERT_TRUE(classifier.load(classifierXmlPath));
+    try
+    {
+        cv::gpu::CascadeClassifier_GPU classifier;
+        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+        ASSERT_TRUE(classifier.load(classifierXmlPath));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
@@ -374,49 +405,57 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_classify, Accuracy)
 {
-    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-    std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
-
-    cv::CascadeClassifier cpuClassifier(classifierXmlPath);
-    ASSERT_FALSE(cpuClassifier.empty());
-
-    cv::Mat image = cv::imread(imagePath);
-    image = image.colRange(0, image.cols/2);
-    cv::Mat grey;
-    cvtColor(image, grey, CV_BGR2GRAY);
-    ASSERT_FALSE(image.empty());
-
-    std::vector<cv::Rect> rects;
-    cpuClassifier.detectMultiScale(grey, rects);
-    cv::Mat markedImage = image.clone();
-
-    std::vector<cv::Rect>::iterator it = rects.begin();
-    for (; it != rects.end(); ++it)
-        cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
-
-    cv::gpu::CascadeClassifier_GPU gpuClassifier;
-    ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
-
-    cv::gpu::GpuMat gpu_rects;
-    cv::gpu::GpuMat tested(grey);
-    int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
-
-#if defined (LOG_CASCADE_STATISTIC)
-    cv::Mat downloaded(gpu_rects);
-    const cv::Rect* faces = downloaded.ptr<cv::Rect>();
-    for (int i = 0; i < count; i++)
+    try
     {
-        cv::Rect r = faces[i];
+        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+        std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
 
-        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
+        cv::CascadeClassifier cpuClassifier(classifierXmlPath);
+        ASSERT_FALSE(cpuClassifier.empty());
+
+        cv::Mat image = cv::imread(imagePath);
+        image = image.colRange(0, image.cols/2);
+        cv::Mat grey;
+        cvtColor(image, grey, CV_BGR2GRAY);
+        ASSERT_FALSE(image.empty());
+
+        std::vector<cv::Rect> rects;
+        cpuClassifier.detectMultiScale(grey, rects);
+        cv::Mat markedImage = image.clone();
+
+        std::vector<cv::Rect>::iterator it = rects.begin();
+        for (; it != rects.end(); ++it)
+            cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
+
+        cv::gpu::CascadeClassifier_GPU gpuClassifier;
+        ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
+
+        cv::gpu::GpuMat gpu_rects;
+        cv::gpu::GpuMat tested(grey);
+        int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
+
+    #if defined (LOG_CASCADE_STATISTIC)
+        cv::Mat downloaded(gpu_rects);
+        const cv::Rect* faces = downloaded.ptr<cv::Rect>();
+        for (int i = 0; i < count; i++)
+        {
+            cv::Rect r = faces[i];
+
+            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
+        }
+    #endif
+
+    #if defined (LOG_CASCADE_STATISTIC)
+        cv::imshow("Res", markedImage); cv::waitKey();
+    #endif
+        (void)count;
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-#endif
-
-#if defined (LOG_CASCADE_STATISTIC)
-    cv::imshow("Res", markedImage); cv::waitKey();
-#endif
-    (void)count;
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index 3bb3e09ea..4be0c153a 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -70,258 +70,402 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
 
 TEST_P(GlBuffer, Constructor1)
 {
-    cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    try
+    {
+        cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_EQ(size.height, buf.rows());
-    EXPECT_EQ(size.width, buf.cols());
-    EXPECT_EQ(type, buf.type());
+        EXPECT_EQ(size.height, buf.rows());
+        EXPECT_EQ(size.width, buf.cols());
+        EXPECT_EQ(type, buf.type());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, Constructor2)
 {
-    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    try
+    {
+        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_EQ(size.height, buf.rows());
-    EXPECT_EQ(size.width, buf.cols());
-    EXPECT_EQ(type, buf.type());
+        EXPECT_EQ(size.height, buf.rows());
+        EXPECT_EQ(size.width, buf.cols());
+        EXPECT_EQ(type, buf.type());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, ConstructorFromMat)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, ConstructorFromGpuMat)
 {
-    cv::Mat gold = randomMat(size, type);
-    cv::gpu::GpuMat d_gold(gold);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
+        cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
+        cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, ConstructorFromGlBuffer)
 {
-    cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    try
+    {
+        cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::GlBuffer buf(buf_gold);
+        cv::GlBuffer buf(buf_gold);
 
-    EXPECT_EQ(buf_gold.bufId(), buf.bufId());
-    EXPECT_EQ(buf_gold.rows(), buf.rows());
-    EXPECT_EQ(buf_gold.cols(), buf.cols());
-    EXPECT_EQ(buf_gold.type(), buf.type());
+        EXPECT_EQ(buf_gold.bufId(), buf.bufId());
+        EXPECT_EQ(buf_gold.rows(), buf.rows());
+        EXPECT_EQ(buf_gold.cols(), buf.cols());
+        EXPECT_EQ(buf_gold.type(), buf.type());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, ConstructorFromGlTexture2D)
 {
-    const int depth = CV_MAT_DEPTH(type);
-    const int cn = CV_MAT_CN(type);
+    try
+    {
+        const int depth = CV_MAT_DEPTH(type);
+        const int cn = CV_MAT_CN(type);
 
-    if (depth != CV_32F || cn == 2)
-        return;
+        if (depth != CV_32F || cn == 2)
+            return;
 
-    cv::Mat gold = randomMat(size, type, 0, 1.0);
-    cv::GlTexture2D tex_gold(gold, true);
+        cv::Mat gold = randomMat(size, type, 0, 1.0);
+        cv::GlTexture2D tex_gold(gold, true);
 
-    cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+        cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, Create)
 {
-    cv::GlBuffer buf;
-    buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    try
+    {
+        cv::GlBuffer buf;
+        buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_EQ(size.height, buf.rows());
-    EXPECT_EQ(size.width, buf.cols());
-    EXPECT_EQ(type, buf.type());
+        EXPECT_EQ(size.height, buf.rows());
+        EXPECT_EQ(size.width, buf.cols());
+        EXPECT_EQ(type, buf.type());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyFromMat)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf;
-    buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf;
+        buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyFromGpuMat)
 {
-    cv::Mat gold = randomMat(size, type);
-    cv::gpu::GpuMat d_gold(gold);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
+        cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlBuffer buf;
-    buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf;
+        buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyFromGlBuffer)
 {
-    cv::Mat gold = randomMat(size, type);
-    cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
+        cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::GlBuffer buf;
-    buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf;
+        buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_NE(buf_gold.bufId(), buf.bufId());
+        EXPECT_NE(buf_gold.bufId(), buf.bufId());
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyFromGlTexture2D)
 {
-    const int depth = CV_MAT_DEPTH(type);
-    const int cn = CV_MAT_CN(type);
+    try
+    {
+        const int depth = CV_MAT_DEPTH(type);
+        const int cn = CV_MAT_CN(type);
 
-    if (depth != CV_32F || cn == 2)
-        return;
+        if (depth != CV_32F || cn == 2)
+            return;
 
-    cv::Mat gold = randomMat(size, type, 0, 1.0);
-    cv::GlTexture2D tex_gold(gold, true);
+        cv::Mat gold = randomMat(size, type, 0, 1.0);
+        cv::GlTexture2D tex_gold(gold, true);
 
-    cv::GlBuffer buf;
-    buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf;
+        buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyToGpuMat)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::gpu::GpuMat dst;
-    buf.copyTo(dst);
+        cv::gpu::GpuMat dst;
+        buf.copyTo(dst);
 
-    EXPECT_MAT_NEAR(gold, dst, 0);
+        EXPECT_MAT_NEAR(gold, dst, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyToGlBuffer)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::GlBuffer dst;
-    buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer dst;
+        buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_NE(buf.bufId(), dst.bufId());
+        EXPECT_NE(buf.bufId(), dst.bufId());
 
-    cv::Mat bufData;
-    dst.copyTo(bufData);
+        cv::Mat bufData;
+        dst.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, CopyToGlTexture2D)
 {
-    const int depth = CV_MAT_DEPTH(type);
-    const int cn = CV_MAT_CN(type);
+    try
+    {
+        const int depth = CV_MAT_DEPTH(type);
+        const int cn = CV_MAT_CN(type);
 
-    if (depth != CV_32F || cn == 2)
-        return;
+        if (depth != CV_32F || cn == 2)
+            return;
 
-    cv::Mat gold = randomMat(size, type, 0, 1.0);
+        cv::Mat gold = randomMat(size, type, 0, 1.0);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-    cv::GlTexture2D tex;
-    buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+        cv::GlTexture2D tex;
+        buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData);
+        cv::Mat texData;
+        tex.copyTo(texData);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, Clone)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
 
-    EXPECT_NE(buf.bufId(), dst.bufId());
+        EXPECT_NE(buf.bufId(), dst.bufId());
 
-    cv::Mat bufData;
-    dst.copyTo(bufData);
+        cv::Mat bufData;
+        dst.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, MapHostRead)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
+        cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
 
-    EXPECT_MAT_NEAR(gold, dst, 0);
+        EXPECT_MAT_NEAR(gold, dst, 0);
 
-    buf.unmapHost();
+        buf.unmapHost();
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, MapHostWrite)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
-    gold.copyTo(dst);
-    buf.unmapHost();
-    dst.release();
+        cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
+        gold.copyTo(dst);
+        buf.unmapHost();
+        dst.release();
 
-    cv::Mat bufData;
-    buf.copyTo(bufData);
+        cv::Mat bufData;
+        buf.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 0);
+        EXPECT_MAT_NEAR(gold, bufData, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlBuffer, MapDevice)
 {
-    cv::Mat gold = randomMat(size, type);
+    try
+    {
+        cv::Mat gold = randomMat(size, type);
 
-    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-    cv::gpu::GpuMat dst = buf.mapDevice();
+        cv::gpu::GpuMat dst = buf.mapDevice();
 
-    EXPECT_MAT_NEAR(gold, dst, 0);
+        EXPECT_MAT_NEAR(gold, dst, 0);
 
-    buf.unmapDevice();
+        buf.unmapDevice();
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@@ -360,147 +504,243 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
 
 TEST_P(GlTexture2D, Constructor1)
 {
-    cv::GlTexture2D tex(size.height, size.width, format, true);
+    try
+    {
+        cv::GlTexture2D tex(size.height, size.width, format, true);
 
-    EXPECT_EQ(size.height, tex.rows());
-    EXPECT_EQ(size.width, tex.cols());
-    EXPECT_EQ(format, tex.format());
+        EXPECT_EQ(size.height, tex.rows());
+        EXPECT_EQ(size.width, tex.cols());
+        EXPECT_EQ(format, tex.format());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, Constructor2)
 {
-    cv::GlTexture2D tex(size, format, true);
+    try
+    {
+        cv::GlTexture2D tex(size, format, true);
 
-    EXPECT_EQ(size.height, tex.rows());
-    EXPECT_EQ(size.width, tex.cols());
-    EXPECT_EQ(format, tex.format());
+        EXPECT_EQ(size.height, tex.rows());
+        EXPECT_EQ(size.width, tex.cols());
+        EXPECT_EQ(format, tex.format());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, ConstructorFromMat)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold, true);
+        cv::GlTexture2D tex(gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, ConstructorFromGpuMat)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::gpu::GpuMat d_gold(gold);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+        cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlTexture2D tex(d_gold, true);
+        cv::GlTexture2D tex(d_gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlBuffer)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-    cv::GlTexture2D tex(buf_gold, true);
+        cv::GlTexture2D tex(buf_gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
 {
-    cv::GlTexture2D tex_gold(size, format, true);
-    cv::GlTexture2D tex(tex_gold);
+    try
+    {
+        cv::GlTexture2D tex_gold(size, format, true);
+        cv::GlTexture2D tex(tex_gold);
 
-    EXPECT_EQ(tex_gold.texId(), tex.texId());
-    EXPECT_EQ(tex_gold.rows(), tex.rows());
-    EXPECT_EQ(tex_gold.cols(), tex.cols());
-    EXPECT_EQ(tex_gold.format(), tex.format());
+        EXPECT_EQ(tex_gold.texId(), tex.texId());
+        EXPECT_EQ(tex_gold.rows(), tex.rows());
+        EXPECT_EQ(tex_gold.cols(), tex.cols());
+        EXPECT_EQ(tex_gold.format(), tex.format());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, Create)
 {
-    cv::GlTexture2D tex;
-    tex.create(size.height, size.width, format, true);
+    try
+    {
+        cv::GlTexture2D tex;
+        tex.create(size.height, size.width, format, true);
 
-    EXPECT_EQ(size.height, tex.rows());
-    EXPECT_EQ(size.width, tex.cols());
-    EXPECT_EQ(format, tex.format());
+        EXPECT_EQ(size.height, tex.rows());
+        EXPECT_EQ(size.width, tex.cols());
+        EXPECT_EQ(format, tex.format());
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, CopyFromMat)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex;
-    tex.copyFrom(gold, true);
+        cv::GlTexture2D tex;
+        tex.copyFrom(gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, CopyFromGpuMat)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::gpu::GpuMat d_gold(gold);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+        cv::gpu::GpuMat d_gold(gold);
 
-    cv::GlTexture2D tex;
-    tex.copyFrom(d_gold, true);
+        cv::GlTexture2D tex;
+        tex.copyFrom(d_gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, CopyFromGlBuffer)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-    cv::GlTexture2D tex;
-    tex.copyFrom(buf_gold, true);
+        cv::GlTexture2D tex;
+        tex.copyFrom(buf_gold, true);
 
-    cv::Mat texData;
-    tex.copyTo(texData, depth);
+        cv::Mat texData;
+        tex.copyTo(texData, depth);
 
-    EXPECT_MAT_NEAR(gold, texData, 1e-2);
+        EXPECT_MAT_NEAR(gold, texData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, CopyToGpuMat)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold, true);
+        cv::GlTexture2D tex(gold, true);
 
-    cv::gpu::GpuMat dst;
-    tex.copyTo(dst, depth);
+        cv::gpu::GpuMat dst;
+        tex.copyTo(dst, depth);
 
-    EXPECT_MAT_NEAR(gold, dst, 1e-2);
+        EXPECT_MAT_NEAR(gold, dst, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GlTexture2D, CopyToGlBuffer)
 {
-    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    try
+    {
+        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-    cv::GlTexture2D tex(gold, true);
+        cv::GlTexture2D tex(gold, true);
 
-    cv::GlBuffer dst;
-    tex.copyTo(dst, depth, true);
+        cv::GlBuffer dst;
+        tex.copyTo(dst, depth, true);
 
-    cv::Mat bufData;
-    dst.copyTo(bufData);
+        cv::Mat bufData;
+        dst.copyTo(bufData);
 
-    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp
index 1abd7841e..ae91b192b 100644
--- a/modules/gpu/test/test_pyramids.cpp
+++ b/modules/gpu/test/test_pyramids.cpp
@@ -66,15 +66,23 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrDown, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
-    cv::gpu::pyrDown(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
+        cv::gpu::pyrDown(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::pyrDown(src, dst_gold);
+        cv::Mat dst_gold;
+        cv::pyrDown(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
@@ -106,15 +114,23 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrUp, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
-    cv::gpu::pyrUp(loadMat(src, useRoi), dst);
+        cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
+        cv::gpu::pyrUp(loadMat(src, useRoi), dst);
 
-    cv::Mat dst_gold;
-    cv::pyrUp(src, dst_gold);
+        cv::Mat dst_gold;
+        cv::pyrUp(src, dst_gold);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp
index 978e1044a..e8b44b5fe 100644
--- a/modules/gpu/test/test_remap.cpp
+++ b/modules/gpu/test/test_remap.cpp
@@ -154,16 +154,24 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
 
 TEST_P(Remap, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Scalar val = randomScalar(0.0, 255.0);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Scalar val = randomScalar(0.0, 255.0);
 
-    cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
-    cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
+        cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
+        cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
 
-    cv::Mat dst_gold;
-    remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
+        cv::Mat dst_gold;
+        remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp
index cae2dbf41..b1b30bb26 100644
--- a/modules/gpu/test/test_resize.cpp
+++ b/modules/gpu/test/test_resize.cpp
@@ -138,15 +138,23 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
 
 TEST_P(Resize, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-    cv::Mat dst_gold;
-    resizeGold(src, dst_gold, coeff, coeff, interpolation);
+        cv::Mat dst_gold;
+        resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
@@ -184,15 +192,23 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
 // downscaling only: used for classifiers
 TEST_P(ResizeSameAsHost, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
 
-    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-    cv::Mat dst_gold;
-    cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
+        cv::Mat dst_gold;
+        cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
@@ -226,16 +242,24 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
 
 TEST_P(ResizeNPP, Accuracy)
 {
-    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-    ASSERT_FALSE(src.empty());
+    try
+    {
+        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+        ASSERT_FALSE(src.empty());
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
+        cv::gpu::GpuMat dst;
+        cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
 
-    cv::Mat dst_gold;
-    resizeGold(src, dst_gold, coeff, coeff, interpolation);
+        cv::Mat dst_gold;
+        resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-    EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
+        EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index cc397404a..695280de5 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include <test_precomp.hpp>
+#include "test_precomp.hpp"
 #include <time.h>
 
 #ifdef HAVE_CUDA
@@ -158,62 +158,77 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
-    cv::gpu::setDevice(GET_PARAM(0).deviceID());
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
-    ASSERT_FALSE(coloredCpu.empty());
-
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(0);
-
-    int nroi = GET_PARAM(3);
-    cv::Mat result(coloredCpu);
-    cv::RNG rng;
-    for (int i = 0; i < nroi; ++i)
+    try
     {
-        cv::Rect r = getFromTable(rng(10));
-        GpuMat sub(rois, r);
-        sub.setTo(1);
-        cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
+        cv::gpu::setDevice(GET_PARAM(0).deviceID());
+        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
+        ASSERT_FALSE(coloredCpu.empty());
+
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(0);
+
+        int nroi = GET_PARAM(3);
+        cv::Mat result(coloredCpu);
+        cv::RNG rng;
+        for (int i = 0; i < nroi; ++i)
+        {
+            cv::Rect r = getFromTable(rng(10));
+            GpuMat sub(rois, r);
+            sub.setTo(1);
+            cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
+        }
+        objectBoxes.setTo(0);
+
+        cascade.detect(colored, rois, objectBoxes);
+
+        cv::Mat dt(objectBoxes);
+        typedef cv::gpu::SCascade::Detection Detection;
+
+        Detection* dts = ((Detection*)dt.data) + 1;
+        int* count = dt.ptr<int>(0);
+
+        printTotal(std::cout, *count);
+
+        for (int i = 0; i  < *count; ++i)
+        {
+            Detection d = dts[i];
+            print(std::cout, d);
+            cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+        }
+
+        SHOW(result);
     }
-    objectBoxes.setTo(0);
-
-    cascade.detect(colored, rois, objectBoxes);
-
-    cv::Mat dt(objectBoxes);
-    typedef cv::gpu::SCascade::Detection Detection;
-
-    Detection* dts = ((Detection*)dt.data) + 1;
-    int* count = dt.ptr<int>(0);
-
-    printTotal(std::cout, *count);
-
-    for (int i = 0; i  < *count; ++i)
+    catch (...)
     {
-        Detection d = dts[i];
-        print(std::cout, d);
-        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    SHOW(result);
-
 }
 
 TEST(SCascadeTest, readCascade)
 {
-    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
-    cv::gpu::SCascade cascade;
+    try
+    {
+        std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
+        cv::gpu::SCascade cascade;
 
-    cv::FileStorage fs(xml, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+        cv::FileStorage fs(xml, cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
 
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
@@ -221,105 +236,129 @@ GPU_TEST_P(SCascadeTestAll, detect,
         ALL_DEVICES
         )
 {
-    cv::gpu::setDevice(GetParam().deviceID());
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SCascade cascade;
+    try
+    {
+        cv::gpu::setDevice(GetParam().deviceID());
+        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+        cv::gpu::SCascade cascade;
 
-    cv::FileStorage fs(xml, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+        cv::FileStorage fs(xml, cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
 
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-    ASSERT_FALSE(coloredCpu.empty());
+        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+        ASSERT_FALSE(coloredCpu.empty());
 
-    GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
-    rois.setTo(0);
-    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-    sub.setTo(cv::Scalar::all(1));
+        GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
+        rois.setTo(0);
+        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+        sub.setTo(cv::Scalar::all(1));
 
-    objectBoxes.setTo(0);
-    cascade.detect(colored, rois, objectBoxes);
+        objectBoxes.setTo(0);
+        cascade.detect(colored, rois, objectBoxes);
 
-    typedef cv::gpu::SCascade::Detection Detection;
-    cv::Mat detections(objectBoxes);
-    int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2448);
+        typedef cv::gpu::SCascade::Detection Detection;
+        cv::Mat detections(objectBoxes);
+        int a = *(detections.ptr<int>(0));
+        ASSERT_EQ(a, 2448);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )
 {
-    cv::gpu::setDevice(GetParam().deviceID());
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SCascade cascade;
-
-    cv::FileStorage fs(xml, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-    std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
-    cv::FileStorage fsi(intPath, cv::FileStorage::READ);
-    ASSERT_TRUE(fsi.isOpened());
-
-    GpuMat hogluv(121 * 10, 161, CV_32SC1);
-    for (int i = 0; i < 10; ++i)
+    try
     {
-        cv::Mat channel;
-        fsi[std::string("channel") + itoa(i)] >> channel;
-        GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-        gchannel.upload(channel);
+        cv::gpu::setDevice(GetParam().deviceID());
+        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+        cv::gpu::SCascade cascade;
+
+        cv::FileStorage fs(xml, cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
+
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+        std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
+        cv::FileStorage fsi(intPath, cv::FileStorage::READ);
+        ASSERT_TRUE(fsi.isOpened());
+
+        GpuMat hogluv(121 * 10, 161, CV_32SC1);
+        for (int i = 0; i < 10; ++i)
+        {
+            cv::Mat channel;
+            fsi[std::string("channel") + itoa(i)] >> channel;
+            GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+            gchannel.upload(channel);
+        }
+
+        GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+        rois.setTo(1);
+
+        objectBoxes.setTo(0);
+        cascade.detect(hogluv, rois, objectBoxes);
+
+        typedef cv::gpu::SCascade::Detection Detection;
+        cv::Mat detections(objectBoxes);
+        int a = *(detections.ptr<int>(0));
+
+        ASSERT_EQ(a, 1024);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-    rois.setTo(1);
-
-    objectBoxes.setTo(0);
-    cascade.detect(hogluv, rois, objectBoxes);
-
-    typedef cv::gpu::SCascade::Detection Detection;
-    cv::Mat detections(objectBoxes);
-    int a = *(detections.ptr<int>(0));
-
-    ASSERT_EQ( a ,1024);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectStream,
         ALL_DEVICES
         )
 {
-    cv::gpu::setDevice(GetParam().deviceID());
-    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-    cv::gpu::SCascade cascade;
+    try
+    {
+        cv::gpu::setDevice(GetParam().deviceID());
+        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+        cv::gpu::SCascade cascade;
 
-    cv::FileStorage fs(xml, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
+        cv::FileStorage fs(xml, cv::FileStorage::READ);
+        ASSERT_TRUE(fs.isOpened());
 
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-    ASSERT_FALSE(coloredCpu.empty());
+        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+        ASSERT_FALSE(coloredCpu.empty());
 
-    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
-    rois.setTo(0);
-    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-    sub.setTo(cv::Scalar::all(1));
+        GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+        rois.setTo(0);
+        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+        sub.setTo(cv::Scalar::all(1));
 
-    cv::gpu::Stream s;
+        cv::gpu::Stream s;
 
-    objectBoxes.setTo(0);
-    cascade.detect(colored, rois, objectBoxes, s);
-    s.waitForCompletion();
+        objectBoxes.setTo(0);
+        cascade.detect(colored, rois, objectBoxes, s);
+        s.waitForCompletion();
 
-    typedef cv::gpu::SCascade::Detection Detection;
-    cv::Mat detections(objectBoxes);
-    int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2448);
+        typedef cv::gpu::SCascade::Detection Detection;
+        cv::Mat detections(objectBoxes);
+        int a = *(detections.ptr<int>(0));
+        ASSERT_EQ(a, 2448);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 
-#endif
\ No newline at end of file
+#endif
diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp
index c56921045..38d92a64d 100644
--- a/modules/gpu/test/test_threshold.cpp
+++ b/modules/gpu/test/test_threshold.cpp
@@ -68,17 +68,25 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
 
 TEST_P(Threshold, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    double maxVal = randomDouble(20.0, 127.0);
-    double thresh = randomDouble(0.0, maxVal);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        double maxVal = randomDouble(20.0, 127.0);
+        double thresh = randomDouble(0.0, maxVal);
 
-    cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-    cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
+        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
 
-    cv::Mat dst_gold;
-    cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+        cv::Mat dst_gold;
+        cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 97e792c7f..6162ee2c9 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -65,67 +65,74 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BroxOpticalFlow, Regression)
 {
-    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-    ASSERT_FALSE(frame0.empty());
+    try
+    {
+        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+        ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-    ASSERT_FALSE(frame1.empty());
+        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+        ASSERT_FALSE(frame1.empty());
 
-    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                  10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                      10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
-    brox(loadMat(frame0), loadMat(frame1), u, v);
+        cv::gpu::GpuMat u;
+        cv::gpu::GpuMat v;
+        brox(loadMat(frame0), loadMat(frame1), u, v);
 
-#ifndef DUMP
-    std::string fname(cvtest::TS::ptr()->get_data_path());
-    if (devInfo.majorVersion() >= 2)
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-    else
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+    #ifndef DUMP
+        std::string fname(cvtest::TS::ptr()->get_data_path());
+        if (devInfo.majorVersion() >= 2)
+            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+        else
+            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-    std::ifstream f(fname.c_str(), std::ios_base::binary);
+        std::ifstream f(fname.c_str(), std::ios_base::binary);
 
-    int rows, cols;
+        int rows, cols;
 
-    f.read((char*)&rows, sizeof(rows));
-    f.read((char*)&cols, sizeof(cols));
+        f.read((char*)&rows, sizeof(rows));
+        f.read((char*)&cols, sizeof(cols));
 
-    cv::Mat u_gold(rows, cols, CV_32FC1);
+        cv::Mat u_gold(rows, cols, CV_32FC1);
 
-    for (int i = 0; i < u_gold.rows; ++i)
-        f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
+        for (int i = 0; i < u_gold.rows; ++i)
+            f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
 
-    cv::Mat v_gold(rows, cols, CV_32FC1);
+        cv::Mat v_gold(rows, cols, CV_32FC1);
 
-    for (int i = 0; i < v_gold.rows; ++i)
-        f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
+        for (int i = 0; i < v_gold.rows; ++i)
+            f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
 
-    EXPECT_MAT_NEAR(u_gold, u, 0);
-    EXPECT_MAT_NEAR(v_gold, v, 0);
-#else
-    std::string fname(cvtest::TS::ptr()->get_data_path());
-    if (devInfo.majorVersion() >= 2)
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-    else
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+        EXPECT_MAT_NEAR(u_gold, u, 0);
+        EXPECT_MAT_NEAR(v_gold, v, 0);
+    #else
+        std::string fname(cvtest::TS::ptr()->get_data_path());
+        if (devInfo.majorVersion() >= 2)
+            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+        else
+            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-    std::ofstream f(fname.c_str(), std::ios_base::binary);
+        std::ofstream f(fname.c_str(), std::ios_base::binary);
 
-    f.write((char*)&u.rows, sizeof(u.rows));
-    f.write((char*)&u.cols, sizeof(u.cols));
+        f.write((char*)&u.rows, sizeof(u.rows));
+        f.write((char*)&u.cols, sizeof(u.cols));
 
-    cv::Mat h_u(u);
-    cv::Mat h_v(v);
+        cv::Mat h_u(u);
+        cv::Mat h_v(v);
 
-    for (int i = 0; i < u.rows; ++i)
-        f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
+        for (int i = 0; i < u.rows; ++i)
+            f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
 
-    for (int i = 0; i < v.rows; ++i)
-        f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
-
-#endif
+        for (int i = 0; i < v.rows; ++i)
+            f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
+    #endif
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@@ -151,28 +158,16 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
 
 TEST_P(GoodFeaturesToTrack, Accuracy)
 {
-    cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    int maxCorners = 1000;
-    double qualityLevel = 0.01;
-
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            cv::gpu::GpuMat d_pts;
-            detector(loadMat(image), d_pts);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
+    try
     {
+        cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(image.empty());
+
+        int maxCorners = 1000;
+        double qualityLevel = 0.01;
+
+        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+
         cv::gpu::GpuMat d_pts;
         detector(loadMat(image), d_pts);
 
@@ -201,21 +196,34 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
 
         ASSERT_LE(bad_ratio, 0.01);
     }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 TEST_P(GoodFeaturesToTrack, EmptyCorners)
 {
-    int maxCorners = 1000;
-    double qualityLevel = 0.01;
+    try
+    {
+        int maxCorners = 1000;
+        double qualityLevel = 0.01;
 
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
 
-    cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
-    cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
+        cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+        cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
 
-    detector(src, corners);
+        detector(src, corners);
 
-    ASSERT_TRUE( corners.empty() );
+        ASSERT_TRUE( corners.empty() );
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
@@ -243,70 +251,78 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
 
 TEST_P(PyrLKOpticalFlow, Sparse)
 {
-    cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Mat gray_frame;
-    if (useGray)
-        gray_frame = frame0;
-    else
-        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
-
-    std::vector<cv::Point2f> pts;
-    cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
-
-    cv::gpu::GpuMat d_pts;
-    cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
-    d_pts.upload(pts_mat);
-
-    cv::gpu::PyrLKOpticalFlow pyrLK;
-
-    cv::gpu::GpuMat d_nextPts;
-    cv::gpu::GpuMat d_status;
-    pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
-
-    std::vector<cv::Point2f> nextPts(d_nextPts.cols);
-    cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
-    d_nextPts.download(nextPts_mat);
-
-    std::vector<unsigned char> status(d_status.cols);
-    cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
-    d_status.download(status_mat);
-
-    std::vector<cv::Point2f> nextPts_gold;
-    std::vector<unsigned char> status_gold;
-    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
-
-    ASSERT_EQ(nextPts_gold.size(), nextPts.size());
-    ASSERT_EQ(status_gold.size(), status.size());
-
-    size_t mistmatch = 0;
-    for (size_t i = 0; i < nextPts.size(); ++i)
+    try
     {
-        cv::Point2i a = nextPts[i];
-        cv::Point2i b = nextPts_gold[i];
+        cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+        ASSERT_FALSE(frame0.empty());
 
-        if (status[i] != status_gold[i])
+        cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+        ASSERT_FALSE(frame1.empty());
+
+        cv::Mat gray_frame;
+        if (useGray)
+            gray_frame = frame0;
+        else
+            cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
+
+        std::vector<cv::Point2f> pts;
+        cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
+
+        cv::gpu::GpuMat d_pts;
+        cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
+        d_pts.upload(pts_mat);
+
+        cv::gpu::PyrLKOpticalFlow pyrLK;
+
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
+        pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
+
+        std::vector<cv::Point2f> nextPts(d_nextPts.cols);
+        cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
+        d_nextPts.download(nextPts_mat);
+
+        std::vector<unsigned char> status(d_status.cols);
+        cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
+        d_status.download(status_mat);
+
+        std::vector<cv::Point2f> nextPts_gold;
+        std::vector<unsigned char> status_gold;
+        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
+
+        ASSERT_EQ(nextPts_gold.size(), nextPts.size());
+        ASSERT_EQ(status_gold.size(), status.size());
+
+        size_t mistmatch = 0;
+        for (size_t i = 0; i < nextPts.size(); ++i)
         {
-            ++mistmatch;
-            continue;
-        }
+            cv::Point2i a = nextPts[i];
+            cv::Point2i b = nextPts_gold[i];
 
-        if (status[i])
-        {
-            bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
-
-            if (!eq)
+            if (status[i] != status_gold[i])
+            {
                 ++mistmatch;
+                continue;
+            }
+
+            if (status[i])
+            {
+                bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
+
+                if (!eq)
+                    ++mistmatch;
+            }
         }
+
+        double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+
+        ASSERT_LE(bad_ratio, 0.01);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
-
-    ASSERT_LE(bad_ratio, 0.01);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
@@ -343,45 +359,53 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn
 
 TEST_P(FarnebackOpticalFlow, Accuracy)
 {
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    double polySigma = polyN <= 5 ? 1.1 : 1.5;
-
-    cv::gpu::FarnebackOpticalFlow calc;
-    calc.pyrScale = pyrScale;
-    calc.polyN = polyN;
-    calc.polySigma = polySigma;
-    calc.flags = flags;
-
-    cv::gpu::GpuMat d_flowx, d_flowy;
-    calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-
-    cv::Mat flow;
-    if (useInitFlow)
+    try
     {
-        cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
-        cv::merge(flowxy, 2, flow);
-    }
+        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame0.empty());
 
-    if (useInitFlow)
-    {
-        calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
+        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame1.empty());
+
+        double polySigma = polyN <= 5 ? 1.1 : 1.5;
+
+        cv::gpu::FarnebackOpticalFlow calc;
+        calc.pyrScale = pyrScale;
+        calc.polyN = polyN;
+        calc.polySigma = polySigma;
+        calc.flags = flags;
+
+        cv::gpu::GpuMat d_flowx, d_flowy;
         calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+
+        cv::Mat flow;
+        if (useInitFlow)
+        {
+            cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
+            cv::merge(flowxy, 2, flow);
+        }
+
+        if (useInitFlow)
+        {
+            calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
+            calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+        }
+
+        cv::calcOpticalFlowFarneback(
+            frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
+            calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
+
+        std::vector<cv::Mat> flowxy;
+        cv::split(flow, flowxy);
+
+        EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
+        EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    cv::calcOpticalFlowFarneback(
-        frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
-        calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
-
-    std::vector<cv::Mat> flowxy;
-    cv::split(flow, flowxy);
-
-    EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
-    EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
@@ -395,27 +419,35 @@ struct OpticalFlowNan : public BroxOpticalFlow {};
 
 TEST_P(OpticalFlowNan, Regression)
 {
-    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-    ASSERT_FALSE(frame0.empty());
-    cv::Mat r_frame0, r_frame1;
-    cv::resize(frame0, r_frame0, cv::Size(1380,1000));
+    try
+    {
+        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+        ASSERT_FALSE(frame0.empty());
+        cv::Mat r_frame0, r_frame1;
+        cv::resize(frame0, r_frame0, cv::Size(1380,1000));
 
-    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-    ASSERT_FALSE(frame1.empty());
-    cv::resize(frame1, r_frame1, cv::Size(1380,1000));
+        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+        ASSERT_FALSE(frame1.empty());
+        cv::resize(frame1, r_frame1, cv::Size(1380,1000));
 
-    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                  5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
+        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                      5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
-    brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
+        cv::gpu::GpuMat u;
+        cv::gpu::GpuMat v;
+        brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
 
-    cv::Mat h_u, h_v;
-    u.download(h_u);
-    v.download(h_v);
-    EXPECT_TRUE(cv::checkRange(h_u));
-    EXPECT_TRUE(cv::checkRange(h_v));
+        cv::Mat h_u, h_v;
+        u.download(h_u);
+        v.download(h_v);
+        EXPECT_TRUE(cv::checkRange(h_u));
+        EXPECT_TRUE(cv::checkRange(h_v));
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 };
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
@@ -429,30 +461,38 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(OpticalFlowDual_TVL1, Accuracy)
 {
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
+    try
+    {
+        cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
 
-    const bool useRoi = GET_PARAM(1);
+        const bool useRoi = GET_PARAM(1);
 
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
+        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
+        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame1.empty());
 
-    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
-    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
-    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+        cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+        cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+        d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
 
-    cv::OpticalFlowDual_TVL1 alg;
-    cv::Mat flow;
-    alg(frame0, frame1, flow);
-    cv::Mat gold[2];
-    cv::split(flow, gold);
+        cv::OpticalFlowDual_TVL1 alg;
+        cv::Mat flow;
+        alg(frame0, frame1, flow);
+        cv::Mat gold[2];
+        cv::split(flow, gold);
 
-    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
-    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
+        EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+        EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
@@ -486,29 +526,37 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(OpticalFlowBM, Accuracy)
 {
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+    try
+    {
+        cv::gpu::DeviceInfo devInfo = GetParam();
+        cv::gpu::setDevice(devInfo.deviceID());
 
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
+        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
+        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame1.empty());
 
-    cv::Size block_size(16, 16);
-    cv::Size shift_size(1, 1);
-    cv::Size max_range(16, 16);
+        cv::Size block_size(16, 16);
+        cv::Size shift_size(1, 1);
+        cv::Size max_range(16, 16);
 
-    cv::gpu::GpuMat d_velx, d_vely, buf;
-    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
-                               block_size, shift_size, max_range, false,
-                               d_velx, d_vely, buf);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
+        cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+                                   block_size, shift_size, max_range, false,
+                                   d_velx, d_vely, buf);
 
-    cv::Mat velx, vely;
-    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+        cv::Mat velx, vely;
+        calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
 
-    EXPECT_MAT_NEAR(velx, d_velx, 0);
-    EXPECT_MAT_NEAR(vely, d_vely, 0);
+        EXPECT_MAT_NEAR(velx, d_velx, 0);
+        EXPECT_MAT_NEAR(vely, d_vely, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
@@ -586,44 +634,52 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastOpticalFlowBM, Accuracy)
 {
-    const double MAX_RMSE = 0.6;
+    try
+    {
+        const double MAX_RMSE = 0.6;
 
-    int search_window = 15;
-    int block_window = 5;
+        int search_window = 15;
+        int block_window = 5;
 
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
+        cv::gpu::DeviceInfo devInfo = GetParam();
+        cv::gpu::setDevice(devInfo.deviceID());
 
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
+        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame0.empty());
 
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
+        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+        ASSERT_FALSE(frame1.empty());
 
-    cv::Size smallSize(320, 240);
-    cv::Mat frame0_small;
-    cv::Mat frame1_small;
+        cv::Size smallSize(320, 240);
+        cv::Mat frame0_small;
+        cv::Mat frame1_small;
 
-    cv::resize(frame0, frame0_small, smallSize);
-    cv::resize(frame1, frame1_small, smallSize);
+        cv::resize(frame0, frame0_small, smallSize);
+        cv::resize(frame1, frame1_small, smallSize);
 
-    cv::gpu::GpuMat d_flowx;
-    cv::gpu::GpuMat d_flowy;
-    cv::gpu::FastOpticalFlowBM fastBM;
+        cv::gpu::GpuMat d_flowx;
+        cv::gpu::GpuMat d_flowy;
+        cv::gpu::FastOpticalFlowBM fastBM;
 
-    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+        fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
 
-    cv::Mat_<float> flowx;
-    cv::Mat_<float> flowy;
-    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+        cv::Mat_<float> flowx;
+        cv::Mat_<float> flowy;
+        FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
 
-    double err;
+        double err;
 
-    err = calc_rmse(flowx, cv::Mat(d_flowx));
-    EXPECT_LE(err, MAX_RMSE);
+        err = calc_rmse(flowx, cv::Mat(d_flowx));
+        EXPECT_LE(err, MAX_RMSE);
 
-    err = calc_rmse(flowy, cv::Mat(d_flowy));
-    EXPECT_LE(err, MAX_RMSE);
+        err = calc_rmse(flowy, cv::Mat(d_flowy));
+        EXPECT_LE(err, MAX_RMSE);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
@@ -658,55 +714,63 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
 
 TEST_P(FGDStatModel, Update)
 {
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    IplImage ipl_frame = frame;
-    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
-
-    cv::gpu::GpuMat d_frame(frame);
-    cv::gpu::FGDStatModel d_model(out_cn);
-    d_model.create(d_frame);
-
-    cv::Mat h_background;
-    cv::Mat h_foreground;
-    cv::Mat h_background3;
-
-    cv::Mat backgroundDiff;
-    cv::Mat foregroundDiff;
-
-    for (int i = 0; i < 5; ++i)
+    try
     {
+        cv::VideoCapture cap(inputFile);
+        ASSERT_TRUE(cap.isOpened());
+
+        cv::Mat frame;
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        ipl_frame = frame;
-        int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
+        IplImage ipl_frame = frame;
+        cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
 
-        d_frame.upload(frame);
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::FGDStatModel d_model(out_cn);
+        d_model.create(d_frame);
 
-        int count = d_model.update(d_frame);
+        cv::Mat h_background;
+        cv::Mat h_foreground;
+        cv::Mat h_background3;
 
-        ASSERT_EQ(gold_count, count);
+        cv::Mat backgroundDiff;
+        cv::Mat foregroundDiff;
 
-        cv::Mat gold_background(model->background);
-        cv::Mat gold_foreground(model->foreground);
-
-        if (out_cn == 3)
-            d_model.background.download(h_background3);
-        else
+        for (int i = 0; i < 5; ++i)
         {
-            d_model.background.download(h_background);
-            cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
-        }
-        d_model.foreground.download(h_foreground);
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-        ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
-        ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+            ipl_frame = frame;
+            int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
+
+            d_frame.upload(frame);
+
+            int count = d_model.update(d_frame);
+
+            ASSERT_EQ(gold_count, count);
+
+            cv::Mat gold_background(model->background);
+            cv::Mat gold_foreground(model->foreground);
+
+            if (out_cn == 3)
+                d_model.background.download(h_background3);
+            else
+            {
+                d_model.background.download(h_background);
+                cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
+            }
+            d_model.foreground.download(h_foreground);
+
+            ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
+            ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+        }
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -745,36 +809,44 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us
 
 TEST_P(MOG, Update)
 {
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    cv::gpu::MOG_GPU mog;
-    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-    cv::BackgroundSubtractorMOG mog_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
+    try
     {
+        cv::VideoCapture cap(inputFile);
+        ASSERT_TRUE(cap.isOpened());
+
+        cv::Mat frame;
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        if (useGray)
+        cv::gpu::MOG_GPU mog;
+        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+        cv::BackgroundSubtractorMOG mog_gold;
+        cv::Mat foreground_gold;
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::Mat temp;
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            cv::swap(temp, frame);
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (useGray)
+            {
+                cv::Mat temp;
+                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                cv::swap(temp, frame);
+            }
+
+            mog(loadMat(frame, useRoi), foreground, (float)learningRate);
+
+            mog_gold(frame, foreground_gold, learningRate);
+
+            ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
         }
-
-        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
-
-        mog_gold(frame, foreground_gold, learningRate);
-
-        ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -810,40 +882,48 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
 
 TEST_P(MOG2, Update)
 {
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
+    try
     {
+        cv::VideoCapture cap(inputFile);
+        ASSERT_TRUE(cap.isOpened());
+
+        cv::Mat frame;
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        if (useGray)
+        cv::gpu::MOG2_GPU mog2;
+        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+        cv::BackgroundSubtractorMOG2 mog2_gold;
+        cv::Mat foreground_gold;
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::Mat temp;
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            cv::swap(temp, frame);
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            if (useGray)
+            {
+                cv::Mat temp;
+                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                cv::swap(temp, frame);
+            }
+
+            mog2(loadMat(frame, useRoi), foreground);
+
+            mog2_gold(frame, foreground_gold);
+
+            double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
+
+            norm /= foreground_gold.size().area();
+
+            ASSERT_LE(norm, 0.09);
         }
-
-        mog2(loadMat(frame, useRoi), foreground);
-
-        mog2_gold(frame, foreground_gold);
-
-        double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
-
-        norm /= foreground_gold.size().area();
-
-        ASSERT_LE(norm, 0.09);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -852,34 +932,42 @@ TEST_P(MOG2, getBackgroundImage)
     if (useGray)
         return;
 
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground;
-
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
+    try
     {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
+        cv::VideoCapture cap(inputFile);
+        ASSERT_TRUE(cap.isOpened());
 
-        mog2(loadMat(frame, useRoi), foreground);
+        cv::Mat frame;
 
-        mog2_gold(frame, foreground_gold);
+        cv::gpu::MOG2_GPU mog2;
+        cv::gpu::GpuMat foreground;
+
+        cv::BackgroundSubtractorMOG2 mog2_gold;
+        cv::Mat foreground_gold;
+
+        for (int i = 0; i < 10; ++i)
+        {
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            mog2(loadMat(frame, useRoi), foreground);
+
+            mog2_gold(frame, foreground_gold);
+        }
+
+        cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
+        mog2.getBackgroundImage(background);
+
+        cv::Mat background_gold;
+        mog2_gold.getBackgroundImage(background_gold);
+
+        ASSERT_MAT_NEAR(background_gold, background, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
-    mog2.getBackgroundImage(background);
-
-    cv::Mat background_gold;
-    mog2_gold.getBackgroundImage(background_gold);
-
-    ASSERT_MAT_NEAR(background_gold, background, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
@@ -897,30 +985,38 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(VIBE, Accuracy)
 {
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const int type = GET_PARAM(2);
-    const bool useRoi = GET_PARAM(3);
+    try
+    {
+        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+        const cv::Size size = GET_PARAM(1);
+        const int type = GET_PARAM(2);
+        const bool useRoi = GET_PARAM(3);
 
-    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
 
-    cv::Mat frame = randomMat(size, type, 0.0, 100);
-    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+        cv::Mat frame = randomMat(size, type, 0.0, 100);
+        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
 
-    cv::gpu::VIBE_GPU vibe;
-    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-    vibe.initialize(d_frame);
+        cv::gpu::VIBE_GPU vibe;
+        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+        vibe.initialize(d_frame);
 
-    for (int i = 0; i < 20; ++i)
+        for (int i = 0; i < 20; ++i)
+            vibe(d_frame, d_fgmask);
+
+        frame = randomMat(size, type, 160, 255);
+        d_frame = loadMat(frame, useRoi);
         vibe(d_frame, d_fgmask);
 
-    frame = randomMat(size, type, 160, 255);
-    d_frame = loadMat(frame, useRoi);
-    vibe(d_frame, d_fgmask);
-
-    // now fgmask should be entirely foreground
-    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
+        // now fgmask should be entirely foreground
+        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
@@ -938,42 +1034,50 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
 
 TEST_P(GMG, Accuracy)
 {
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const int depth = GET_PARAM(2);
-    const int channels = GET_PARAM(3);
-    const bool useRoi = GET_PARAM(4);
-
-    const int type = CV_MAKE_TYPE(depth, channels);
-
-    const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
-    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
-
-    cv::Mat frame = randomMat(size, type, 0, 100);
-    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
-
-    cv::gpu::GMG_GPU gmg;
-    gmg.numInitializationFrames = 5;
-    gmg.smoothingRadius = 0;
-    gmg.initialize(d_frame.size(), 0, 255);
-
-    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-
-    for (int i = 0; i < gmg.numInitializationFrames; ++i)
+    try
     {
+        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+        const cv::Size size = GET_PARAM(1);
+        const int depth = GET_PARAM(2);
+        const int channels = GET_PARAM(3);
+        const bool useRoi = GET_PARAM(4);
+
+        const int type = CV_MAKE_TYPE(depth, channels);
+
+        const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
+        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+
+        cv::Mat frame = randomMat(size, type, 0, 100);
+        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+
+        cv::gpu::GMG_GPU gmg;
+        gmg.numInitializationFrames = 5;
+        gmg.smoothingRadius = 0;
+        gmg.initialize(d_frame.size(), 0, 255);
+
+        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+
+        for (int i = 0; i < gmg.numInitializationFrames; ++i)
+        {
+            gmg(d_frame, d_fgmask);
+
+            // fgmask should be entirely background during training
+            ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
+        }
+
+        frame = randomMat(size, type, 160, 255);
+        d_frame = loadMat(frame, useRoi);
         gmg(d_frame, d_fgmask);
 
-        // fgmask should be entirely background during training
-        ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
+        // now fgmask should be entirely foreground
+        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
     }
-
-    frame = randomMat(size, type, 160, 255);
-    d_frame = loadMat(frame, useRoi);
-    gmg(d_frame, d_fgmask);
-
-    // now fgmask should be entirely foreground
-    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
@@ -1009,39 +1113,47 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoWriter, Regression)
 {
-    const double FPS = 25.0;
-
-    cv::VideoCapture reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
-
-    cv::gpu::VideoWriter_GPU d_writer;
-
-    cv::Mat frame;
-    cv::gpu::GpuMat d_frame;
-
-    for (int i = 0; i < 10; ++i)
+    try
     {
-        reader >> frame;
-        ASSERT_FALSE(frame.empty());
+        const double FPS = 25.0;
 
-        d_frame.upload(frame);
+        cv::VideoCapture reader(inputFile);
+        ASSERT_TRUE( reader.isOpened() );
 
-        if (!d_writer.isOpened())
-            d_writer.open(outputFile, frame.size(), FPS);
+        cv::gpu::VideoWriter_GPU d_writer;
 
-        d_writer.write(d_frame);
+        cv::Mat frame;
+        cv::gpu::GpuMat d_frame;
+
+        for (int i = 0; i < 10; ++i)
+        {
+            reader >> frame;
+            ASSERT_FALSE(frame.empty());
+
+            d_frame.upload(frame);
+
+            if (!d_writer.isOpened())
+                d_writer.open(outputFile, frame.size(), FPS);
+
+            d_writer.write(d_frame);
+        }
+
+        reader.release();
+        d_writer.close();
+
+        reader.open(outputFile);
+        ASSERT_TRUE( reader.isOpened() );
+
+        for (int i = 0; i < 5; ++i)
+        {
+            reader >> frame;
+            ASSERT_FALSE( frame.empty() );
+        }
     }
-
-    reader.release();
-    d_writer.close();
-
-    reader.open(outputFile);
-    ASSERT_TRUE( reader.isOpened() );
-
-    for (int i = 0; i < 5; ++i)
+    catch (...)
     {
-        reader >> frame;
-        ASSERT_FALSE( frame.empty() );
+        cv::gpu::resetDevice();
+        throw;
     }
 }
 
@@ -1070,19 +1182,27 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoReader, Regression)
 {
-    cv::gpu::VideoReader_GPU reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
-
-    cv::gpu::GpuMat frame;
-
-    for (int i = 0; i < 10; ++i)
+    try
     {
-        ASSERT_TRUE( reader.read(frame) );
-        ASSERT_FALSE( frame.empty() );
-    }
+        cv::gpu::VideoReader_GPU reader(inputFile);
+        ASSERT_TRUE( reader.isOpened() );
 
-    reader.close();
-    ASSERT_FALSE( reader.isOpened() );
+        cv::gpu::GpuMat frame;
+
+        for (int i = 0; i < 10; ++i)
+        {
+            ASSERT_TRUE( reader.read(frame) );
+            ASSERT_FALSE( frame.empty() );
+        }
+
+        reader.close();
+        ASSERT_FALSE( reader.isOpened() );
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp
index 065c6755e..256f7504a 100644
--- a/modules/gpu/test/test_warp_affine.cpp
+++ b/modules/gpu/test/test_warp_affine.cpp
@@ -76,24 +76,32 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
 
 TEST_P(BuildWarpAffineMaps, Accuracy)
 {
-    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-    cv::gpu::GpuMat xmap, ymap;
-    cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
+    try
+    {
+        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+        cv::gpu::GpuMat xmap, ymap;
+        cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
 
-    int interpolation = cv::INTER_NEAREST;
-    int borderMode = cv::BORDER_CONSTANT;
+        int interpolation = cv::INTER_NEAREST;
+        int borderMode = cv::BORDER_CONSTANT;
 
-    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-    cv::Mat dst;
-    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+        cv::Mat dst;
+        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
 
-    int flags = interpolation;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
-    cv::Mat dst_gold;
-    cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
+        int flags = interpolation;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
+        cv::Mat dst_gold;
+        cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
@@ -201,20 +209,28 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
 
 TEST_P(WarpAffine, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-    int flags = interpolation;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
-    cv::Scalar val = randomScalar(0.0, 255.0);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+        int flags = interpolation;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
+        cv::Scalar val = randomScalar(0.0, 255.0);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-    cv::Mat dst_gold;
-    warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+        cv::Mat dst_gold;
+        warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
@@ -249,19 +265,27 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
 
 TEST_P(WarpAffineNPP, Accuracy)
 {
-    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-    int flags = interpolation;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
+    try
+    {
+        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+        int flags = interpolation;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
+        cv::gpu::GpuMat dst;
+        cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
 
-    cv::Mat dst_gold;
-    warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+        cv::Mat dst_gold;
+        warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
+        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp
index 95c089bb9..77e88d43d 100644
--- a/modules/gpu/test/test_warp_perspective.cpp
+++ b/modules/gpu/test/test_warp_perspective.cpp
@@ -77,21 +77,29 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
 
 TEST_P(BuildWarpPerspectiveMaps, Accuracy)
 {
-    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-    cv::gpu::GpuMat xmap, ymap;
-    cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
+    try
+    {
+        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+        cv::gpu::GpuMat xmap, ymap;
+        cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
 
-    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-    cv::Mat dst;
-    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
+        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+        cv::Mat dst;
+        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
 
-    int flags = cv::INTER_NEAREST;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
-    cv::Mat dst_gold;
-    cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
+        int flags = cv::INTER_NEAREST;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
+        cv::Mat dst_gold;
+        cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
@@ -201,20 +209,28 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
 
 TEST_P(WarpPerspective, Accuracy)
 {
-    cv::Mat src = randomMat(size, type);
-    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-    int flags = interpolation;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
-    cv::Scalar val = randomScalar(0.0, 255.0);
+    try
+    {
+        cv::Mat src = randomMat(size, type);
+        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+        int flags = interpolation;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
+        cv::Scalar val = randomScalar(0.0, 255.0);
 
-    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-    cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-    cv::Mat dst_gold;
-    warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+        cv::Mat dst_gold;
+        warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
+        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
@@ -249,19 +265,27 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
 
 TEST_P(WarpPerspectiveNPP, Accuracy)
 {
-    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-    int flags = interpolation;
-    if (inverse)
-        flags |= cv::WARP_INVERSE_MAP;
+    try
+    {
+        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+        int flags = interpolation;
+        if (inverse)
+            flags |= cv::WARP_INVERSE_MAP;
 
-    cv::gpu::GpuMat dst;
-    cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
+        cv::gpu::GpuMat dst;
+        cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
 
-    cv::Mat dst_gold;
-    warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+        cv::Mat dst_gold;
+        warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
+        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
+    }
+    catch (...)
+    {
+        cv::gpu::resetDevice();
+        throw;
+    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(

From 41c9377db02c233a31b05e9df3093ded88b6738c Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Tue, 18 Dec 2012 18:03:54 +0400
Subject: [PATCH 148/155] fixed warnings under windows

---
 modules/gpu/src/cascadeclassifier.cpp  |  2 +-
 modules/gpu/src/element_operations.cpp |  8 ++++----
 modules/gpu/src/fgd_bgfg.cpp           |  6 +++---
 modules/gpu/src/hough.cpp              |  2 +-
 modules/gpu/src/softcascade.cpp        |  6 +++---
 modules/gpu/test/test_hough.cpp        |  2 +-
 modules/gpu/test/test_labeling.cpp     |  2 +-
 modules/gpu/test/test_video.cpp        |  4 ++--
 samples/gpu/houghlines.cpp             |  6 +++---
 samples/gpu/optical_flow.cpp           | 22 +++++++++++-----------
 10 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/modules/gpu/src/cascadeclassifier.cpp b/modules/gpu/src/cascadeclassifier.cpp
index 07e174e5c..360393397 100644
--- a/modules/gpu/src/cascadeclassifier.cpp
+++ b/modules/gpu/src/cascadeclassifier.cpp
@@ -623,7 +623,7 @@ private:
         }
 
         // copy data structures on gpu
-        stage_mat.upload(cv::Mat(1, stages.size() * sizeof(Stage), CV_8UC1, (uchar*)&(stages[0]) ));
+        stage_mat.upload(cv::Mat(1, (int) (stages.size() * sizeof(Stage)), CV_8UC1, (uchar*)&(stages[0]) ));
         trees_mat.upload(cv::Mat(cl_trees).reshape(1,1));
         nodes_mat.upload(cv::Mat(cl_nodes).reshape(1,1));
         leaves_mat.upload(cv::Mat(cl_leaves).reshape(1,1));
diff --git a/modules/gpu/src/element_operations.cpp b/modules/gpu/src/element_operations.cpp
index 1943b315d..3d6cde377 100644
--- a/modules/gpu/src/element_operations.cpp
+++ b/modules/gpu/src/element_operations.cpp
@@ -2086,7 +2086,7 @@ void cv::gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, St
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    const int bcols = src.cols * src.elemSize();
+    const int bcols = (int) (src.cols * src.elemSize());
 
     if ((bcols & 3) == 0)
     {
@@ -2139,7 +2139,7 @@ void cv::gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, c
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    const int bcols = src1.cols * src1.elemSize();
+    const int bcols = (int) (src1.cols * src1.elemSize());
 
     if ((bcols & 3) == 0)
     {
@@ -2186,7 +2186,7 @@ void cv::gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, co
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    const int bcols = src1.cols * src1.elemSize();
+    const int bcols = (int) (src1.cols * src1.elemSize());
 
     if ((bcols & 3) == 0)
     {
@@ -2233,7 +2233,7 @@ void cv::gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, c
 
     cudaStream_t stream = StreamAccessor::getStream(s);
 
-    const int bcols = src1.cols * src1.elemSize();
+    const int bcols = (int) (src1.cols * src1.elemSize());
 
     if ((bcols & 3) == 0)
     {
diff --git a/modules/gpu/src/fgd_bgfg.cpp b/modules/gpu/src/fgd_bgfg.cpp
index e0f695d44..1576f69d1 100644
--- a/modules/gpu/src/fgd_bgfg.cpp
+++ b/modules/gpu/src/fgd_bgfg.cpp
@@ -523,15 +523,15 @@ namespace
 
         size_t total = all_contours.size();
 
-        _contours.create(total, 1, 0, -1, true);
+        _contours.create((int) total, 1, 0, -1, true);
 
         cv::SeqIterator<CvSeq*> it = all_contours.begin();
         for (size_t i = 0; i < total; ++i, ++it)
         {
             CvSeq* c = *it;
             ((CvContour*)c)->color = (int)i;
-            _contours.create((int)c->total, 1, CV_32SC2, i, true);
-            cv::Mat ci = _contours.getMat(i);
+            _contours.create((int)c->total, 1, CV_32SC2, (int)i, true);
+            cv::Mat ci = _contours.getMat((int)i);
             CV_Assert( ci.isContinuous() );
             cvCvtSeqToArray(c, ci.data);
         }
diff --git a/modules/gpu/src/hough.cpp b/modules/gpu/src/hough.cpp
index 1b9c786c3..09cf01850 100644
--- a/modules/gpu/src/hough.cpp
+++ b/modules/gpu/src/hough.cpp
@@ -579,7 +579,7 @@ namespace
         const func_t func = funcs[dx.depth()];
         CV_Assert(func != 0);
 
-        edgePointList.cols = edgePointList.step / sizeof(int);
+        edgePointList.cols = (int) (edgePointList.step / sizeof(int));
         ensureSizeIsEnough(2, edges.size().area(), CV_32SC1, edgePointList);
 
         edgePointList.cols = func(edges, dx, dy, edgePointList.ptr<unsigned int>(0), edgePointList.ptr<float>(1));
diff --git a/modules/gpu/src/softcascade.cpp b/modules/gpu/src/softcascade.cpp
index 9c9132bb1..695fab58c 100644
--- a/modules/gpu/src/softcascade.cpp
+++ b/modules/gpu/src/softcascade.cpp
@@ -235,13 +235,13 @@ struct cv::gpu::SCascade::Fields
             ++octIndex;
         }
 
-        cv::Mat hoctaves(1, voctaves.size() * sizeof(Octave), CV_8UC1, (uchar*)&(voctaves[0]));
+        cv::Mat hoctaves(1, (int) (voctaves.size() * sizeof(Octave)), CV_8UC1, (uchar*)&(voctaves[0]));
         CV_Assert(!hoctaves.empty());
 
         cv::Mat hstages(cv::Mat(vstages).reshape(1,1));
         CV_Assert(!hstages.empty());
 
-        cv::Mat hnodes(1, vnodes.size() * sizeof(Node), CV_8UC1, (uchar*)&(vnodes[0]) );
+        cv::Mat hnodes(1, (int) (vnodes.size() * sizeof(Node)), CV_8UC1, (uchar*)&(vnodes[0]) );
         CV_Assert(!hnodes.empty());
 
         cv::Mat hleaves(cv::Mat(vleaves).reshape(1,1));
@@ -296,7 +296,7 @@ struct cv::gpu::SCascade::Fields
             scale = ::std::min(maxScale, ::expf(::log(scale) + logFactor));
         }
 
-        cv::Mat hlevels = cv::Mat(1, vlevels.size() * sizeof(Level), CV_8UC1, (uchar*)&(vlevels[0]) );
+        cv::Mat hlevels = cv::Mat(1, (int) (vlevels.size() * sizeof(Level)), CV_8UC1, (uchar*)&(vlevels[0]) );
         CV_Assert(!hlevels.empty());
         levels.upload(hlevels);
         downscales = dcs;
diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp
index 9c4a97470..76ed0c618 100644
--- a/modules/gpu/test/test_hough.cpp
+++ b/modules/gpu/test/test_hough.cpp
@@ -89,7 +89,7 @@ TEST_P(HoughLines, Accuracy)
         const bool useRoi = GET_PARAM(2);
 
         const float rho = 1.0f;
-        const float theta = 1.5f * CV_PI / 180.0f;
+        const float theta = (float) (1.5 * CV_PI / 180.0);
         const int threshold = 100;
 
         cv::Mat src(size, CV_8UC1);
diff --git a/modules/gpu/test/test_labeling.cpp b/modules/gpu/test/test_labeling.cpp
index f5e79cd46..21ee03bcf 100644
--- a/modules/gpu/test/test_labeling.cpp
+++ b/modules/gpu/test/test_labeling.cpp
@@ -82,7 +82,7 @@ namespace {
             int cc = -1;
 
             int* dist_labels = (int*)labels.data;
-            int pitch = labels.step1();
+            int pitch = (int) labels.step1();
 
             unsigned char* source = (unsigned char*)image.data;
             int width = image.cols;
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 6162ee2c9..d1332ce5f 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -606,8 +606,8 @@ static void FastOpticalFlowBM_gold(const cv::Mat_<uchar>& I0, const cv::Mat_<uch
                 }
             }
 
-            velx(y, x) = bestDx;
-            vely(y, x) = bestDy;
+            velx(y, x) = (float) bestDx;
+            vely(y, x) = (float) bestDy;
         }
     }
 }
diff --git a/samples/gpu/houghlines.cpp b/samples/gpu/houghlines.cpp
index 4aa4cb153..e98dcc6e7 100644
--- a/samples/gpu/houghlines.cpp
+++ b/samples/gpu/houghlines.cpp
@@ -38,7 +38,7 @@ int main(int argc, const char* argv[])
 
     vector<Vec4i> lines_cpu;
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         HoughLinesP(mask, lines_cpu, 1, CV_PI / 180, 50, 60, 5);
 
@@ -57,9 +57,9 @@ int main(int argc, const char* argv[])
     GpuMat d_lines;
     HoughLinesBuf d_buf;
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
-        gpu::HoughLinesP(d_src, d_lines, d_buf, 1, CV_PI / 180, 50, 5);
+        gpu::HoughLinesP(d_src, d_lines, d_buf, 1.0f, (float) (CV_PI / 180.0f), 50, 5);
 
         const double timeSec = (getTickCount() - start) / getTickFrequency();
         cout << "GPU Time : " << timeSec * 1000 << " ms" << endl;
diff --git a/samples/gpu/optical_flow.cpp b/samples/gpu/optical_flow.cpp
index 8afff89ea..3f74d1b67 100644
--- a/samples/gpu/optical_flow.cpp
+++ b/samples/gpu/optical_flow.cpp
@@ -57,7 +57,7 @@ static Vec3b computeColor(float fx, float fy)
     }
 
     const float rad = sqrt(fx * fx + fy * fy);
-    const float a = atan2(-fy, -fx) / CV_PI;
+    const float a = atan2(-fy, -fx) / (float) CV_PI;
 
     const float fk = (a + 1.0f) / 2.0f * (NCOLS - 1);
     const int k0 = static_cast<int>(fk);
@@ -68,8 +68,8 @@ static Vec3b computeColor(float fx, float fy)
 
     for (int b = 0; b < 3; b++)
     {
-        const float col0 = colorWheel[k0][b] / 255.0;
-        const float col1 = colorWheel[k1][b] / 255.0;
+        const float col0 = colorWheel[k0][b] / 255.0f;
+        const float col1 = colorWheel[k1][b] / 255.0f;
 
         float col = (1 - f) * col0 + f * col1;
 
@@ -78,7 +78,7 @@ static Vec3b computeColor(float fx, float fy)
         else
             col *= .75; // out of range
 
-        pix[2 - b] = static_cast<int>(255.0 * col);
+        pix[2 - b] = static_cast<uchar>(255.0 * col);
     }
 
     return pix;
@@ -166,7 +166,7 @@ int main(int argc, const char* argv[])
     GpuMat d_flowx(frame0.size(), CV_32FC1);
     GpuMat d_flowy(frame0.size(), CV_32FC1);
 
-    BroxOpticalFlow brox(0.197, 50.0, 0.8, 10, 77, 10);
+    BroxOpticalFlow brox(0.197f, 50.0f, 0.8f, 10, 77, 10);
     PyrLKOpticalFlow lk; lk.winSize = Size(7, 7);
     FarnebackOpticalFlow farn;
     OpticalFlowDual_TVL1_GPU tvl1;
@@ -179,7 +179,7 @@ int main(int argc, const char* argv[])
         d_frame0.convertTo(d_frame0f, CV_32F, 1.0 / 255.0);
         d_frame1.convertTo(d_frame1f, CV_32F, 1.0 / 255.0);
 
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         brox(d_frame0f, d_frame1f, d_flowx, d_flowy);
 
@@ -190,7 +190,7 @@ int main(int argc, const char* argv[])
     }
 
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         lk.dense(d_frame0, d_frame1, d_flowx, d_flowy);
 
@@ -201,7 +201,7 @@ int main(int argc, const char* argv[])
     }
 
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         farn(d_frame0, d_frame1, d_flowx, d_flowy);
 
@@ -212,7 +212,7 @@ int main(int argc, const char* argv[])
     }
 
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         tvl1(d_frame0, d_frame1, d_flowx, d_flowy);
 
@@ -223,7 +223,7 @@ int main(int argc, const char* argv[])
     }
 
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         GpuMat buf;
         calcOpticalFlowBM(d_frame0, d_frame1, Size(7, 7), Size(1, 1), Size(21, 21), false, d_flowx, d_flowy, buf);
@@ -235,7 +235,7 @@ int main(int argc, const char* argv[])
     }
 
     {
-        const double start = getTickCount();
+        const int64 start = getTickCount();
 
         fastBM(d_frame0, d_frame1, d_flowx, d_flowy);
 

From 4ba33fa1ed05451d93027bf497ac15d23cf0aa29 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 19 Dec 2012 11:13:31 +0400
Subject: [PATCH 149/155] Revert "call resetDevice if gpu test fails"

This reverts commit ab25fe9e377fdbd69c916d5124483fa26e4a7835.
---
 modules/gpu/app/nv_perf_test/main.cpp      |  176 +-
 modules/gpu/perf/perf_calib3d.cpp          |  230 +-
 modules/gpu/perf/perf_core.cpp             |  963 ++-----
 modules/gpu/perf/perf_denoising.cpp        |  104 +-
 modules/gpu/perf/perf_features2d.cpp       |  184 +-
 modules/gpu/perf/perf_filters.cpp          |  230 +-
 modules/gpu/perf/perf_imgproc.cpp          | 1121 +++-----
 modules/gpu/perf/perf_labeling.cpp         |   36 +-
 modules/gpu/perf/perf_matop.cpp            |   96 +-
 modules/gpu/perf/perf_objdetect.cpp        |  110 +-
 modules/gpu/perf/perf_softcascade.cpp      |  270 +-
 modules/gpu/perf/perf_video.cpp            |  760 +++---
 modules/gpu/test/nvidia/main_nvidia.cpp    |    6 +-
 modules/gpu/test/test_calib3d.cpp          |  282 +--
 modules/gpu/test/test_color.cpp            | 2586 +++++++------------
 modules/gpu/test/test_copy_make_border.cpp |   22 +-
 modules/gpu/test/test_core.cpp             | 2672 ++++++++------------
 modules/gpu/test/test_denoising.cpp        |  111 +-
 modules/gpu/test/test_features2d.cpp       |  862 ++++---
 modules/gpu/test/test_filters.cpp          |  218 +-
 modules/gpu/test/test_global_motion.cpp    |   52 +-
 modules/gpu/test/test_gpumat.cpp           |  324 +--
 modules/gpu/test/test_hough.cpp            |  236 +-
 modules/gpu/test/test_imgproc.cpp          |  726 ++----
 modules/gpu/test/test_labeling.cpp         |   34 +-
 modules/gpu/test/test_nvidia.cpp           |  139 +-
 modules/gpu/test/test_objdetect.cpp        |  355 ++-
 modules/gpu/test/test_opengl.cpp           |  620 ++---
 modules/gpu/test/test_pyramids.cpp         |   40 +-
 modules/gpu/test/test_remap.cpp            |   22 +-
 modules/gpu/test/test_resize.cpp           |   62 +-
 modules/gpu/test/test_softcascade.cpp      |  277 +-
 modules/gpu/test/test_threshold.cpp        |   24 +-
 modules/gpu/test/test_video.cpp            | 1010 ++++----
 modules/gpu/test/test_warp_affine.cpp      |   94 +-
 modules/gpu/test/test_warp_perspective.cpp |   90 +-
 36 files changed, 5694 insertions(+), 9450 deletions(-)

diff --git a/modules/gpu/app/nv_perf_test/main.cpp b/modules/gpu/app/nv_perf_test/main.cpp
index 96a5151c6..928b30a19 100644
--- a/modules/gpu/app/nv_perf_test/main.cpp
+++ b/modules/gpu/app/nv_perf_test/main.cpp
@@ -92,23 +92,15 @@ PERF_TEST_P(Image, HoughLinesP,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
+        cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
             cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -163,25 +155,17 @@ PERF_TEST_P(Image_Depth, GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
+
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_pts;
+
+        d_detector(d_src, d_pts, d_mask);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k);
-
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_pts;
-
             d_detector(d_src, d_pts, d_mask);
-
-            TEST_CYCLE()
-            {
-                d_detector(d_src, d_pts, d_mask);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -260,31 +244,23 @@ PERF_TEST_P(ImagePair_Depth_GraySource, OpticalFlowPyrLKSparse,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
+
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = winSize;
+        d_pyrLK.maxLevel = maxLevel;
+        d_pyrLK.iters = criteria.maxCount;
+        d_pyrLK.useInitialFlow = false;
+
+        d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
-            cv::gpu::GpuMat d_nextPts;
-            cv::gpu::GpuMat d_status;
-
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = winSize;
-            d_pyrLK.maxLevel = maxLevel;
-            d_pyrLK.iters = criteria.maxCount;
-            d_pyrLK.useInitialFlow = false;
-
             d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
-
-            TEST_CYCLE()
-            {
-                d_pyrLK.sparse(d_src1, d_src2, d_pts, d_nextPts, d_status);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -346,33 +322,25 @@ PERF_TEST_P(ImagePair_Depth, OpticalFlowFarneback,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
+        cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
+
+        cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.numLevels = numLevels;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
+
+        d_farneback(d_src1, d_src2, d_u, d_v);
+
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_u(src1.size(), CV_32FC1, cv::Scalar::all(0));
-            cv::gpu::GpuMat d_v(src1.size(), CV_32FC1, cv::Scalar::all(0));
-
-            cv::gpu::FarnebackOpticalFlow d_farneback;
-            d_farneback.pyrScale = pyrScale;
-            d_farneback.numLevels = numLevels;
-            d_farneback.winSize = winSize;
-            d_farneback.numIters = numIters;
-            d_farneback.polyN = polyN;
-            d_farneback.polySigma = polySigma;
-            d_farneback.flags = flags;
-
             d_farneback(d_src1, d_src2, d_u, d_v);
-
-            TEST_CYCLE_N(10)
-            {
-                d_farneback(d_src1, d_src2, d_u, d_v);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -441,23 +409,15 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_velx, d_vely, buf;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
 
+        cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+        TEST_CYCLE_N(10)
+        {
             cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
-            TEST_CYCLE_N(10)
-            {
-                cv::gpu::calcOpticalFlowBM(d_src1, d_src2, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -500,25 +460,17 @@ PERF_TEST_P(ImagePair_BlockSize_ShiftSize_MaxRange, FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_velx, d_vely;
+
+        cv::gpu::FastOpticalFlowBM fastBM;
+
+        fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
+
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_velx, d_vely;
-
-            cv::gpu::FastOpticalFlowBM fastBM;
-
             fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
-
-            TEST_CYCLE_N(10)
-            {
-                fastBM(d_src1, d_src2, d_velx, d_vely, max_range.width, block_size.width);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
diff --git a/modules/gpu/perf/perf_calib3d.cpp b/modules/gpu/perf/perf_calib3d.cpp
index 3a086d9a8..906024f64 100644
--- a/modules/gpu/perf/perf_calib3d.cpp
+++ b/modules/gpu/perf/perf_calib3d.cpp
@@ -26,28 +26,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBM, Values(pair_string("gpu/perf/aloe.png",
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
+
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
+
+        d_bm(d_imgLeft, d_imgRight, d_dst);
+
+        TEST_CYCLE()
         {
-            cv::gpu::StereoBM_GPU d_bm(preset, ndisp);
-
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
-
             d_bm(d_imgLeft, d_imgRight, d_dst);
-
-            TEST_CYCLE()
-            {
-                d_bm(d_imgLeft, d_imgRight, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -83,28 +75,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoBeliefPropagation, Values(pair_string("gpu/
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::StereoBeliefPropagation d_bp(ndisp);
+
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
+
+        d_bp(d_imgLeft, d_imgRight, d_dst);
+
+        TEST_CYCLE()
         {
-            cv::gpu::StereoBeliefPropagation d_bp(ndisp);
-
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
-
             d_bp(d_imgLeft, d_imgRight, d_dst);
-
-            TEST_CYCLE()
-            {
-                d_bp(d_imgLeft, d_imgRight, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -129,28 +113,20 @@ PERF_TEST_P(ImagePair, Calib3D_StereoConstantSpaceBP, Values(pair_string("gpu/st
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
+
+        cv::gpu::GpuMat d_imgLeft(imgLeft);
+        cv::gpu::GpuMat d_imgRight(imgRight);
+        cv::gpu::GpuMat d_dst;
+
+        d_csbp(d_imgLeft, d_imgRight, d_dst);
+
+        TEST_CYCLE()
         {
-            cv::gpu::StereoConstantSpaceBP d_csbp(ndisp);
-
-            cv::gpu::GpuMat d_imgLeft(imgLeft);
-            cv::gpu::GpuMat d_imgRight(imgRight);
-            cv::gpu::GpuMat d_dst;
-
             d_csbp(d_imgLeft, d_imgRight, d_dst);
-
-            TEST_CYCLE()
-            {
-                d_csbp(d_imgLeft, d_imgRight, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -173,28 +149,20 @@ PERF_TEST_P(ImagePair, Calib3D_DisparityBilateralFilter, Values(pair_string("gpu
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::DisparityBilateralFilter d_filter(ndisp);
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_disp(disp);
+        cv::gpu::GpuMat d_dst;
+
+        d_filter(d_disp, d_img, d_dst);
+
+        TEST_CYCLE()
         {
-            cv::gpu::DisparityBilateralFilter d_filter(ndisp);
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_disp(disp);
-            cv::gpu::GpuMat d_dst;
-
             d_filter(d_disp, d_img, d_dst);
-
-            TEST_CYCLE()
-            {
-                d_filter(d_disp, d_img, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -219,25 +187,17 @@ PERF_TEST_P(Count, Calib3D_TransformPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::transformPoints(d_src, rvec, tvec, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -261,25 +221,17 @@ PERF_TEST_P(Count, Calib3D_ProjectPoints, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::projectPoints(d_src, rvec, tvec, camera_mat, cv::Mat(), d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -331,19 +283,11 @@ PERF_TEST_P(Count, Calib3D_SolvePnPRansac, Values(5000, 10000, 20000))
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
+
+        TEST_CYCLE()
         {
             cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::solvePnPRansac(object, image, camera_mat, dist_coef, rvec, tvec);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -376,25 +320,17 @@ PERF_TEST_P(Sz_Depth, Calib3D_ReprojectImageTo3D, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
+
+        TEST_CYCLE()
+        {
             cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::reprojectImageTo3D(d_src, d_dst, Q);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -424,25 +360,17 @@ PERF_TEST_P(Sz_Depth, Calib3D_DrawColorDisp, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::drawColorDisp(d_src, d_dst, 255);
+
+        TEST_CYCLE()
+        {
             cv::gpu::drawColorDisp(d_src, d_dst, 255);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::drawColorDisp(d_src, d_dst, 255);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_core.cpp b/modules/gpu/perf/perf_core.cpp
index 92d87c2e2..ad722fa3b 100644
--- a/modules/gpu/perf/perf_core.cpp
+++ b/modules/gpu/perf/perf_core.cpp
@@ -22,23 +22,15 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Merge, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            std::vector<cv::gpu::GpuMat> d_src(channels);
-            for (int i = 0; i < channels; ++i)
-                d_src[i].upload(src[i]);
+        std::vector<cv::gpu::GpuMat> d_src(channels);
+        for (int i = 0; i < channels; ++i)
+            d_src[i].upload(src[i]);
 
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::merge(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-12);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-12);
     }
     else
     {
@@ -63,22 +55,14 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Split, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_D
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_src(src);
 
-            std::vector<cv::gpu::GpuMat> d_dst;
+        std::vector<cv::gpu::GpuMat> d_dst;
 
-            TEST_CYCLE() cv::gpu::split(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::split(d_src, d_dst);
 
-            cv::gpu::GpuMat first = d_dst[0];
-            GPU_SANITY_CHECK(first, 1e-12);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        cv::gpu::GpuMat first = d_dst[0];
+        GPU_SANITY_CHECK(first, 1e-12);
     }
     else
     {
@@ -106,21 +90,13 @@ PERF_TEST_P(Sz_Depth, Core_AddMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_DEP
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -147,20 +123,12 @@ PERF_TEST_P(Sz_Depth, Core_AddScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::add(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -188,21 +156,13 @@ PERF_TEST_P(Sz_Depth, Core_SubtractMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -229,20 +189,12 @@ PERF_TEST_P(Sz_Depth, Core_SubtractScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::subtract(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -270,21 +222,13 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MA
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::multiply(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -311,22 +255,14 @@ PERF_TEST_P(Sz_Depth, Core_MultiplyScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            cv::gpu::multiply(d_src, s, d_dst);
+        cv::gpu::multiply(d_src, s, d_dst);
 
-            TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::multiply(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -354,21 +290,13 @@ PERF_TEST_P(Sz_Depth, Core_DivideMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -395,20 +323,12 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_M
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::divide(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -435,20 +355,12 @@ PERF_TEST_P(Sz_Depth, Core_DivideScalarInv, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
+        TEST_CYCLE() cv::gpu::divide(s, d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -476,21 +388,13 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_MAT
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -517,20 +421,12 @@ PERF_TEST_P(Sz_Depth, Core_AbsDiffScalar, Combine(GPU_TYPICAL_MAT_SIZES, ARITHM_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
+        TEST_CYCLE() cv::gpu::absdiff(d_src, s, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -555,20 +451,12 @@ PERF_TEST_P(Sz_Depth, Core_Abs, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_16S, CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::abs(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else FAIL_NO_CPU();
 }
@@ -586,20 +474,12 @@ PERF_TEST_P(Sz_Depth, Core_Sqr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqr(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else FAIL_NO_CPU();
 }
@@ -617,20 +497,12 @@ PERF_TEST_P(Sz_Depth, Core_Sqrt, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::sqrt(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -655,20 +527,12 @@ PERF_TEST_P(Sz_Depth, Core_Log, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::log(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::log(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -693,20 +557,12 @@ PERF_TEST_P(Sz_Depth, Core_Exp, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U, CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::exp(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -734,20 +590,12 @@ PERF_TEST_P(Sz_Depth_Power, Core_Pow, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
+        TEST_CYCLE() cv::gpu::pow(d_src, power, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -781,21 +629,13 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareMat, Combine(GPU_TYPICAL_MAT_SIZES, ARITH
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
+        TEST_CYCLE() cv::gpu::compare(d_src1, d_src2, d_dst, cmp_code);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -823,20 +663,12 @@ PERF_TEST_P(Sz_Depth_Code, Core_CompareScalar, Combine(GPU_TYPICAL_MAT_SIZES, AR
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
+        TEST_CYCLE() cv::gpu::compare(d_src, s, d_dst, cmp_code);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -861,20 +693,12 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseNot, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_not(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -902,21 +726,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseAndMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -944,20 +760,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseAndScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_and(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -985,21 +793,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseOrMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(C
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1029,20 +829,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseOrScalar, Combine(GPU_TYPICAL_MAT_SIZES, Va
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_or(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1070,21 +862,13 @@ PERF_TEST_P(Sz_Depth, Core_BitwiseXorMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1112,20 +896,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_BitwiseXorScalar, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
+        TEST_CYCLE() cv::gpu::bitwise_xor(d_src, s,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1155,20 +931,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_RShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::rshift(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1194,20 +962,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_LShift, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::lshift(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1231,21 +991,13 @@ PERF_TEST_P(Sz_Depth, Core_MinMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::min(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1272,20 +1024,12 @@ PERF_TEST_P(Sz_Depth, Core_MinScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::min(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1313,21 +1057,13 @@ PERF_TEST_P(Sz_Depth, Core_MaxMat, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
+        TEST_CYCLE() cv::gpu::max(d_src1, d_src2,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1354,20 +1090,12 @@ PERF_TEST_P(Sz_Depth, Core_MaxScalar, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
+        TEST_CYCLE() cv::gpu::max(d_src, val,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1403,21 +1131,13 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
+        TEST_CYCLE() cv::gpu::addWeighted(d_src1, 0.5, d_src2, 0.5, 10.0, d_dst, dst_depth);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1432,8 +1152,6 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted, Combine(
 //////////////////////////////////////////////////////////////////////
 // GEMM
 
-#ifdef HAVE_CUBLAS
-
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
 #define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T)
 
@@ -1461,22 +1179,14 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_src3(src3);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_src3(src3);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
+        TEST_CYCLE() cv::gpu::gemm(d_src1, d_src2, 1.0, d_src3, 1.0, d_dst, flags);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1490,8 +1200,6 @@ PERF_TEST_P(Sz_Type_Flags, Core_GEMM, Combine(
     }
 }
 
-#endif // HAVE_CUBLAS
-
 //////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -1507,20 +1215,12 @@ PERF_TEST_P(Sz_Type, Core_Transpose, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::transpose(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1559,20 +1259,12 @@ PERF_TEST_P(Sz_Depth_Cn_Code, Core_Flip, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
+        TEST_CYCLE() cv::gpu::flip(d_src, d_dst, flipCode);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1602,20 +1294,12 @@ PERF_TEST_P(Sz_Type, Core_LutOneChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1645,20 +1329,12 @@ PERF_TEST_P(Sz_Type, Core_LutMultiChannel, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
+        TEST_CYCLE() cv::gpu::LUT(d_src, lut,d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1682,20 +1358,12 @@ PERF_TEST_P(Sz, Core_MagnitudeComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src,d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1722,20 +1390,12 @@ PERF_TEST_P(Sz, Core_MagnitudeSqrComplex, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1758,21 +1418,13 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::magnitude(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1781,6 +1433,7 @@ PERF_TEST_P(Sz, Core_Magnitude, GPU_TYPICAL_MAT_SIZES)
         TEST_CYCLE() cv::magnitude(src1, src2, dst);
 
         CPU_SANITY_CHECK(dst, 1e-8);
+
     }
 }
 
@@ -1799,21 +1452,13 @@ PERF_TEST_P(Sz, Core_MagnitudeSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
+        TEST_CYCLE() cv::gpu::magnitudeSqr(d_src1, d_src2, d_dst);
 
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1839,21 +1484,13 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_Phase, Combine(GPU_TYPICAL_MAT_SIZES, Bool()
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
+        TEST_CYCLE() cv::gpu::phase(d_src1, d_src2, d_dst, angleInDegrees);
 
-            GPU_SANITY_CHECK(d_dst, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1e-8);
     }
     else
     {
@@ -1881,23 +1518,16 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_CartToPolar, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_magnitude;
-            cv::gpu::GpuMat d_angle;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_magnitude;
+        cv::gpu::GpuMat d_angle;
 
-            TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+        TEST_CYCLE() cv::gpu::cartToPolar(d_src1, d_src2, d_magnitude, d_angle, angleInDegrees);
+
+        GPU_SANITY_CHECK(d_magnitude, 1e-8);
+        GPU_SANITY_CHECK(d_angle, 1e-8);
 
-            GPU_SANITY_CHECK(d_magnitude, 1e-8);
-            GPU_SANITY_CHECK(d_angle, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
     }
     else
     {
@@ -1927,23 +1557,15 @@ PERF_TEST_P(Sz_AngleInDegrees, Core_PolarToCart, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_magnitude(magnitude);
-            cv::gpu::GpuMat d_angle(angle);
-            cv::gpu::GpuMat d_x;
-            cv::gpu::GpuMat d_y;
+        cv::gpu::GpuMat d_magnitude(magnitude);
+        cv::gpu::GpuMat d_angle(angle);
+        cv::gpu::GpuMat d_x;
+        cv::gpu::GpuMat d_y;
 
-            TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
+        TEST_CYCLE() cv::gpu::polarToCart(d_magnitude, d_angle, d_x, d_y, angleInDegrees);
 
-            GPU_SANITY_CHECK(d_x, 1e-8);
-            GPU_SANITY_CHECK(d_y, 1e-8);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_x, 1e-8);
+        GPU_SANITY_CHECK(d_y, 1e-8);
     }
     else
     {
@@ -1972,18 +1594,10 @@ PERF_TEST_P(Sz, Core_MeanStdDev, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() cv::gpu::meanStdDev(d_src, mean, stddev, d_buf);
     }
     else
     {
@@ -2014,18 +1628,10 @@ PERF_TEST_P(Sz_Depth_Norm, Core_Norm, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::norm(d_src, normType, d_buf);
     }
     else
     {
@@ -2057,18 +1663,11 @@ PERF_TEST_P(Sz_Norm, Core_NormDiff, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+
+        TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
 
-            TEST_CYCLE() dst = cv::gpu::norm(d_src1, d_src2, normType);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
     }
     else
     {
@@ -2099,18 +1698,10 @@ PERF_TEST_P(Sz_Depth_Cn, Core_Sum, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::sum(d_src, d_buf);
     }
     else
     {
@@ -2141,20 +1732,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumAbs, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::absSum(d_src, d_buf);
 
-            SANITY_CHECK(dst, 1e-6);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
@@ -2183,20 +1766,12 @@ PERF_TEST_P(Sz_Depth_Cn, Core_SumSqr, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
+        TEST_CYCLE() dst = cv::gpu::sqrSum(d_src, d_buf);
 
-            SANITY_CHECK(dst, 1e-6);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(dst, 1e-6);
     }
     else
     {
@@ -2221,21 +1796,13 @@ PERF_TEST_P(Sz_Depth, Core_MinMax, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
+        TEST_CYCLE() cv::gpu::minMax(d_src, &minVal, &maxVal, cv::gpu::GpuMat(), d_buf);
 
-            SANITY_CHECK(minVal);
-            SANITY_CHECK(maxVal);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        SANITY_CHECK(minVal);
+        SANITY_CHECK(maxVal);
     }
     else
     {
@@ -2261,18 +1828,10 @@ PERF_TEST_P(Sz_Depth, Core_MinMaxLoc, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_valbuf, d_locbuf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_valbuf, d_locbuf;
 
-            TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() cv::gpu::minMaxLoc(d_src, &minVal, &maxVal, &minLoc, &maxLoc, cv::gpu::GpuMat(), d_valbuf, d_locbuf);
     }
     else
     {
@@ -2304,18 +1863,10 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_buf;
 
-            TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        TEST_CYCLE() dst = cv::gpu::countNonZero(d_src, d_buf);
     }
     else
     {
@@ -2357,20 +1908,12 @@ PERF_TEST_P(Sz_Depth_Cn_Code_Dim, Core_Reduce, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
-            TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
+        TEST_CYCLE() cv::gpu::reduce(d_src, d_dst, dim, reduceOp);
 
-            GPU_SANITY_CHECK(d_dst, 1);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        GPU_SANITY_CHECK(d_dst, 1);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_denoising.cpp b/modules/gpu/perf/perf_denoising.cpp
index 0be16cbfd..ed63177dd 100644
--- a/modules/gpu/perf/perf_denoising.cpp
+++ b/modules/gpu/perf/perf_denoising.cpp
@@ -30,27 +30,19 @@ PERF_TEST_P(Sz_Depth_Cn_KernelSz, Denoising_BilateralFilter,
     cv::Mat src(size, type);
     fillRandom(src);
 
-    if (PERF_RUN_GPU())
+     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::bilateralFilter(d_src, d_dst, kernel_size, sigma_color, sigma_spatial, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -95,25 +87,17 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_NonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::nonLocalMeans(d_src, d_dst, h, search_widow_size, block_size, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -146,26 +130,18 @@ PERF_TEST_P(Sz_Depth_Cn_WinSz_BlockSz, Denoising_FastNonLocalMeans,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::FastNonLocalMeansDenoising fnlmd;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
+        fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
+
+        TEST_CYCLE()
+        {
             fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
-
-            TEST_CYCLE()
-            {
-                fnlmd.simpleMethod(d_src, d_dst, h, search_widow_size, block_size);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -205,26 +181,18 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::FastNonLocalMeansDenoising fnlmd;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
+        fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
+
+        TEST_CYCLE()
+        {
             fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-
-            TEST_CYCLE()
-            {
-                fnlmd.labMethod(d_src, d_dst, h, h, search_widow_size, block_size);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -238,4 +206,4 @@ PERF_TEST_P(Sz_Depth_WinSz_BlockSz, Denoising_FastNonLocalMeansColored,
 
         CPU_SANITY_CHECK(dst);
     }
-}
+}
\ No newline at end of file
diff --git a/modules/gpu/perf/perf_features2d.cpp b/modules/gpu/perf/perf_features2d.cpp
index a0ecf0435..a93cef9b3 100644
--- a/modules/gpu/perf/perf_features2d.cpp
+++ b/modules/gpu/perf/perf_features2d.cpp
@@ -19,28 +19,20 @@ PERF_TEST_P(Image, Features2D_SURF, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::SURF_GPU d_surf;
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
+
+        d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+
+        TEST_CYCLE()
         {
-            cv::gpu::SURF_GPU d_surf;
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints, d_descriptors;
-
             d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-
-            TEST_CYCLE()
-            {
-                d_surf(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-            }
-
-            GPU_SANITY_CHECK(d_descriptors, 1e-4);
-            GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_descriptors, 1e-4);
+        GPU_SANITY_CHECK_KEYPOINTS(SURF, d_keypoints);
     }
     else
     {
@@ -72,27 +64,19 @@ PERF_TEST_P(Image, Features2D_FAST, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::FAST_GPU d_fast(20);
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints;
+
+        d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
+
+        TEST_CYCLE()
         {
-            cv::gpu::FAST_GPU d_fast(20);
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints;
-
             d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
-
-            TEST_CYCLE()
-            {
-                d_fast(d_img, cv::gpu::GpuMat(), d_keypoints);
-            }
-
-            GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK_RESPONSE(FAST, d_keypoints);
     }
     else
     {
@@ -120,28 +104,20 @@ PERF_TEST_P(Image, Features2D_ORB, Values<string>("gpu/perf/aloe.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::ORB_GPU d_orb(4000);
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_keypoints, d_descriptors;
+
+        d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
+
+        TEST_CYCLE()
         {
-            cv::gpu::ORB_GPU d_orb(4000);
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_keypoints, d_descriptors;
-
             d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-
-            TEST_CYCLE()
-            {
-                d_orb(d_img, cv::gpu::GpuMat(), d_keypoints, d_descriptors);
-            }
-
-            GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
-            GPU_SANITY_CHECK(d_descriptors);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK_KEYPOINTS(ORB, d_keypoints);
+        GPU_SANITY_CHECK(d_descriptors);
     }
     else
     {
@@ -185,29 +161,21 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFMatch, Combine(Values(64, 128, 256), Val
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
+
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance;
+
+        d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
+
+        TEST_CYCLE()
         {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_distance;
-
             d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
-
-            TEST_CYCLE()
-            {
-                d_matcher.matchSingle(d_query, d_train, d_trainIdx, d_distance);
-            }
-
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
@@ -252,29 +220,21 @@ PERF_TEST_P(DescSize_K_Norm, Features2D_BFKnnMatch, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
+
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
+
+        d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
+
+        TEST_CYCLE()
         {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_distance, d_allDist;
-
             d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
-
-            TEST_CYCLE()
-            {
-                d_matcher.knnMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_allDist, k);
-            }
-
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
@@ -313,29 +273,21 @@ PERF_TEST_P(DescSize_Norm, Features2D_BFRadiusMatch, Combine(Values(64, 128, 256
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::BFMatcher_GPU d_matcher(normType);
+
+        cv::gpu::GpuMat d_query(query);
+        cv::gpu::GpuMat d_train(train);
+        cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
+
+        d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
+
+        TEST_CYCLE()
         {
-            cv::gpu::BFMatcher_GPU d_matcher(normType);
-
-            cv::gpu::GpuMat d_query(query);
-            cv::gpu::GpuMat d_train(train);
-            cv::gpu::GpuMat d_trainIdx, d_nMatches, d_distance;
-
             d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
-
-            TEST_CYCLE()
-            {
-                d_matcher.radiusMatchSingle(d_query, d_train, d_trainIdx, d_distance, d_nMatches, 2.0);
-            }
-
-            GPU_SANITY_CHECK(d_trainIdx);
-            GPU_SANITY_CHECK(d_distance);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_trainIdx);
+        GPU_SANITY_CHECK(d_distance);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_filters.cpp b/modules/gpu/perf/perf_filters.cpp
index 47265fe11..7faf93e97 100644
--- a/modules/gpu/perf/perf_filters.cpp
+++ b/modules/gpu/perf/perf_filters.cpp
@@ -23,25 +23,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Blur, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
+
+        TEST_CYCLE()
+        {
             cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
-
-            TEST_CYCLE()
-            {
-                cv::gpu::blur(d_src, d_dst, cv::Size(ksize, ksize));
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -74,26 +66,18 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Sobel, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
+
+        TEST_CYCLE()
+        {
             cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::Sobel(d_src, d_dst, -1, 1, 1, d_buf, ksize);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -125,26 +109,18 @@ PERF_TEST_P(Sz_Type, Filters_Scharr, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::Scharr(d_src, d_dst, -1, 1, 0, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -177,26 +153,18 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_GaussianBlur, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
+
+        TEST_CYCLE()
+        {
             cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::GaussianBlur(d_src, d_dst, cv::Size(ksize, ksize), d_buf, 0.5);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -229,25 +197,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Laplacian, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
+
+        TEST_CYCLE()
+        {
             cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::Laplacian(d_src, d_dst, -1, ksize);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -281,26 +241,18 @@ PERF_TEST_P(Sz_Type, Filters_Erode, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8UC
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::erode(d_src, d_dst, ker, d_buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::erode(d_src, d_dst, ker, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::erode(d_src, d_dst, ker, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -334,26 +286,18 @@ PERF_TEST_P(Sz_Type, Filters_Dilate, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8U
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::dilate(d_src, d_dst, ker, d_buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::dilate(d_src, d_dst, ker, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::dilate(d_src, d_dst, ker, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -393,27 +337,19 @@ PERF_TEST_P(Sz_Type_Op, Filters_MorphologyEx, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf1;
-            cv::gpu::GpuMat d_buf2;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf1;
+        cv::gpu::GpuMat d_buf2;
 
+        cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
+
+        TEST_CYCLE()
+        {
             cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::morphologyEx(d_src, d_dst, morphOp, ker, d_buf1, d_buf2);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -449,25 +385,17 @@ PERF_TEST_P(Sz_Type_KernelSz, Filters_Filter2D, Combine(GPU_TYPICAL_MAT_SIZES, V
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::filter2D(d_src, d_dst, -1, kernel);
+
+        TEST_CYCLE()
+        {
             cv::gpu::filter2D(d_src, d_dst, -1, kernel);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::filter2D(d_src, d_dst, -1, kernel);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_imgproc.cpp b/modules/gpu/perf/perf_imgproc.cpp
index 545b8df5a..ee0968442 100644
--- a/modules/gpu/perf/perf_imgproc.cpp
+++ b/modules/gpu/perf/perf_imgproc.cpp
@@ -80,27 +80,19 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border_Mode, ImgProc_Remap, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_xmap(xmap);
-            cv::gpu::GpuMat d_ymap(ymap);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_xmap(xmap);
+        cv::gpu::GpuMat d_ymap(ymap);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::remap(d_src, d_dst, d_xmap, d_ymap, interpolation, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -142,25 +134,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Scale, ImgProc_Resize, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+
+        TEST_CYCLE()
+        {
             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -201,25 +185,17 @@ PERF_TEST_P(Sz_Depth_Cn_Scale, ImgProc_ResizeArea, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
+
+        TEST_CYCLE()
+        {
             cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::resize(d_src, d_dst, cv::Size(), f, f, interpolation);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -266,25 +242,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpAffine, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::warpAffine(d_src, d_dst, M, size, interpolation, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -330,25 +298,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter_Border, ImgProc_WarpPerspective, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::warpPerspective(d_src, d_dst, M, size, interpolation, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -386,25 +346,17 @@ PERF_TEST_P(Sz_Depth_Cn_Border, ImgProc_CopyMakeBorder, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::copyMakeBorder(d_src, d_dst, 5, 5, 5, 5, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -441,25 +393,17 @@ PERF_TEST_P(Sz_Depth_Op, ImgProc_Threshold, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
+
+        TEST_CYCLE()
+        {
             cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::threshold(d_src, d_dst, 100.0, 255.0, threshOp);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -486,26 +430,18 @@ PERF_TEST_P(Sz, ImgProc_Integral, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::integralBuffered(d_src, d_dst, d_buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::integralBuffered(d_src, d_dst, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -532,25 +468,17 @@ PERF_TEST_P(Sz, ImgProc_IntegralSqr, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::sqrIntegral(d_src, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::sqrIntegral(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::sqrIntegral(d_src, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -571,26 +499,18 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC1, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
+
+        TEST_CYCLE()
+        {
             cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::histEven(d_src, d_hist, d_buf, 30, 0, 180);
-            }
-
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -628,26 +548,18 @@ PERF_TEST_P(Sz_Depth, ImgProc_HistEvenC4, Combine(GPU_TYPICAL_MAT_SIZES, Values(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist[4];
-            cv::gpu::GpuMat d_buf, d_hist0;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist[4];
+        cv::gpu::GpuMat d_buf, d_hist0;
 
+        cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
+
+        TEST_CYCLE()
+        {
             cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::histEven(d_src, d_hist, d_buf, histSize, lowerLevel, upperLevel);
-            }
-
-            GPU_SANITY_CHECK(d_hist0);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_hist0);
     }
     else
     {
@@ -667,25 +579,17 @@ PERF_TEST_P(Sz, ImgProc_CalcHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_hist;
 
+        cv::gpu::calcHist(d_src, d_hist);
+
+        TEST_CYCLE()
+        {
             cv::gpu::calcHist(d_src, d_hist);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::calcHist(d_src, d_hist);
-            }
-
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -705,27 +609,19 @@ PERF_TEST_P(Sz, ImgProc_EqualizeHist, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_hist;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_hist;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::equalizeHist(d_src, d_dst, d_hist, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_hist);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_hist);
     }
     else
     {
@@ -752,25 +648,17 @@ PERF_TEST_P(Sz, ImgProc_ColumnSum, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::columnSum(d_src, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::columnSum(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::columnSum(d_src, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -797,26 +685,18 @@ PERF_TEST_P(Image_AppertureSz_L2gradient, ImgProc_Canny, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::CannyBuf d_buf;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::CannyBuf d_buf;
 
+        cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
+
+        TEST_CYCLE()
+        {
             cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::Canny(d_image, d_buf, d_dst, 50.0, 100.0, apperture_size, useL2gradient);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -848,25 +728,17 @@ PERF_TEST_P(Image, ImgProc_MeanShiftFiltering, Values<string>("gpu/meanshift/con
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
+
+        TEST_CYCLE()
+        {
             cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftFiltering(d_src, d_dst, 50, 50);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -896,26 +768,18 @@ PERF_TEST_P(Image, ImgProc_MeanShiftProc, Values<string>("gpu/meanshift/cones.pn
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
-            cv::gpu::GpuMat d_dstr;
-            cv::gpu::GpuMat d_dstsp;
+        cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_dstr;
+        cv::gpu::GpuMat d_dstsp;
 
+        cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
+
+        TEST_CYCLE()
+        {
             cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftProc(d_src, d_dstr, d_dstsp, 50, 50);
-            }
-
-            GPU_SANITY_CHECK(d_dstr);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dstr);
     }
     else
     {
@@ -940,24 +804,16 @@ PERF_TEST_P(Image, ImgProc_MeanShiftSegmentation, Values<string>("gpu/meanshift/
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(rgba);
+        cv::gpu::GpuMat d_src(rgba);
 
+        cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
+
+        TEST_CYCLE()
+        {
             cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::meanShiftSegmentation(d_src, dst, 10, 10, 20);
-            }
-
-            GPU_SANITY_CHECK(dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(dst);
     }
     else
     {
@@ -984,28 +840,20 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_BlendLinear, Combine(GPU_TYPICAL_MAT_SIZES, Val
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img1(img1);
-            cv::gpu::GpuMat d_img2(img2);
-            cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
-            cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_img1(img1);
+        cv::gpu::GpuMat d_img2(img2);
+        cv::gpu::GpuMat d_weights1(size, CV_32FC1, cv::Scalar::all(0.5));
+        cv::gpu::GpuMat d_weights2(size, CV_32FC1, cv::Scalar::all(0.5));
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::blendLinear(d_img1, d_img2, d_weights1, d_weights2, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1034,31 +882,23 @@ PERF_TEST_P(Sz_KernelSz_Ccorr, ImgProc_Convolve, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
+        d_image.upload(image);
+
+        cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
+        d_templ.upload(templ);
+
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::ConvolveBuf d_buf;
+
+        cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_image = cv::gpu::createContinuous(size, CV_32FC1);
-            d_image.upload(image);
-
-            cv::gpu::GpuMat d_templ = cv::gpu::createContinuous(templ_size, templ_size, CV_32FC1);
-            d_templ.upload(templ);
-
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::ConvolveBuf d_buf;
-
             cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::convolve(d_image, d_templ, d_dst, ccorr, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1104,26 +944,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate8U, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_templ(templ);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_templ(templ);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+
+        TEST_CYCLE()
+        {
             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1162,26 +994,18 @@ PERF_TEST_P(Sz_TemplateSz_Cn_Method, ImgProc_MatchTemplate32F, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_templ(templ);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_templ(templ);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
+
+        TEST_CYCLE()
+        {
             cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::matchTemplate(d_image, d_templ, d_dst, method);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1220,26 +1044,18 @@ PERF_TEST_P(Sz_Flags, ImgProc_MulSpectrums, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_a(a);
-            cv::gpu::GpuMat d_b(b);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_a(a);
+        cv::gpu::GpuMat d_b(b);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
+
+        TEST_CYCLE()
+        {
             cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::mulSpectrums(d_a, d_b, d_dst, flag);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1273,26 +1089,18 @@ PERF_TEST_P(Sz, ImgProc_MulAndScaleSpectrums, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src1(src1);
-            cv::gpu::GpuMat d_src2(src2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src1(src1);
+        cv::gpu::GpuMat d_src2(src2);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
+
+        TEST_CYCLE()
+        {
             cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::mulAndScaleSpectrums(d_src1, d_src2, d_dst, cv::DFT_ROWS, scale, false);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1317,25 +1125,17 @@ PERF_TEST_P(Sz_Flags, ImgProc_Dft, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::dft(d_src, d_dst, size, flag);
+
+        TEST_CYCLE()
+        {
             cv::gpu::dft(d_src, d_dst, size, flag);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::dft(d_src, d_dst, size, flag);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1378,28 +1178,20 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerHarris, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_Dx;
-            cv::gpu::GpuMat d_Dy;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_Dx;
+        cv::gpu::GpuMat d_Dy;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::cornerHarris(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, k, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1439,28 +1231,20 @@ PERF_TEST_P(Image_Type_Border_BlockSz_ApertureSz, ImgProc_CornerMinEigenVal, Com
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_dst;
-            cv::gpu::GpuMat d_Dx;
-            cv::gpu::GpuMat d_Dy;
-            cv::gpu::GpuMat d_buf;
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_Dx;
+        cv::gpu::GpuMat d_Dy;
+        cv::gpu::GpuMat d_buf;
 
+        cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
+
+        TEST_CYCLE()
+        {
             cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::cornerMinEigenVal(d_img, d_dst, d_Dx, d_Dy, d_buf, blockSize, apertureSize, borderMode);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1490,26 +1274,18 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpPlaneMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
+        cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
+
+        TEST_CYCLE()
+        {
             cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpPlaneMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, T, 1.0, d_map_x, d_map_y);
-            }
-
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
     }
     else
     {
@@ -1529,26 +1305,18 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpCylindricalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
+        cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+
+        TEST_CYCLE()
+        {
             cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpCylindricalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-            }
-
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
     }
     else
     {
@@ -1568,26 +1336,19 @@ PERF_TEST_P(Sz, ImgProc_BuildWarpSphericalMaps, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_map_x;
-            cv::gpu::GpuMat d_map_y;
+        cv::gpu::GpuMat d_map_x;
+        cv::gpu::GpuMat d_map_y;
 
+        cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
+
+        TEST_CYCLE()
+        {
             cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::buildWarpSphericalMaps(size, cv::Rect(0, 0, size.width, size.height), K, R, 1.0, d_map_x, d_map_y);
-            }
-
-            GPU_SANITY_CHECK(d_map_x);
-            GPU_SANITY_CHECK(d_map_y);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_map_x);
+        GPU_SANITY_CHECK(d_map_y);
+
     }
     else
     {
@@ -1618,25 +1379,17 @@ PERF_TEST_P(Sz_Depth_Cn_Inter, ImgProc_Rotate, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
+
+        TEST_CYCLE()
+        {
             cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::rotate(d_src, d_dst, size, 30.0, 0, 0, interpolation);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1663,25 +1416,17 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrDown, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::pyrDown(d_src, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::pyrDown(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::pyrDown(d_src, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1717,25 +1462,17 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_PyrUp, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::pyrUp(d_src, d_dst);
+
+        TEST_CYCLE()
+        {
             cv::gpu::pyrUp(d_src, d_dst);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::pyrUp(d_src, d_dst);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1796,25 +1533,17 @@ PERF_TEST_P(Sz_Depth_Code, ImgProc_CvtColor, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
+
+        TEST_CYCLE()
+        {
             cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::cvtColor(d_src, d_dst, info.code, info.dcn);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1845,24 +1574,16 @@ PERF_TEST_P(Sz, ImgProc_SwapChannels, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_src(src);
 
+        cv::gpu::swapChannels(d_src, dstOrder);
+
+        TEST_CYCLE()
+        {
             cv::gpu::swapChannels(d_src, dstOrder);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::swapChannels(d_src, dstOrder);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -1892,26 +1613,18 @@ PERF_TEST_P(Sz_Type_Op, ImgProc_AlphaComp, Combine(GPU_TYPICAL_MAT_SIZES, Values
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_img1(img1);
-            cv::gpu::GpuMat d_img2(img2);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_img1(img1);
+        cv::gpu::GpuMat d_img2(img2);
+        cv::gpu::GpuMat d_dst;
 
+        cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
+
+        TEST_CYCLE()
+        {
             cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::alphaComp(d_img1, d_img2, d_dst, alpha_op);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -1935,26 +1648,18 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidBuild, Combine(GPU_TYPICAL_MAT_SIZE
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_src(src);
+
+        cv::gpu::ImagePyramid d_pyr;
+
+        d_pyr.build(d_src, 5);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_src(src);
-
-            cv::gpu::ImagePyramid d_pyr;
-
             d_pyr.build(d_src, 5);
-
-            TEST_CYCLE()
-            {
-                d_pyr.build(d_src, 5);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -1980,27 +1685,19 @@ PERF_TEST_P(Sz_Depth_Cn, ImgProc_ImagePyramidGetLayer, Combine(GPU_TYPICAL_MAT_S
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
+
+        cv::gpu::ImagePyramid d_pyr(d_src, 3);
+
+        d_pyr.getLayer(d_dst, dstSize);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
-
-            cv::gpu::ImagePyramid d_pyr(d_src, 3);
-
             d_pyr.getLayer(d_dst, dstSize);
-
-            TEST_CYCLE()
-            {
-                d_pyr.getLayer(d_dst, dstSize);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -2065,30 +1762,22 @@ PERF_TEST_P(Sz, ImgProc_HoughLines, GPU_TYPICAL_MAT_SIZES)
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
+        cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
+
+        TEST_CYCLE()
+        {
             cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLines(d_src, d_lines, d_buf, rho, theta, threshold);
-            }
-
-            cv::Mat h_lines(d_lines);
-            cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
-            cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
-            std::sort(begin, end, Vec2fComparator());
-            SANITY_CHECK(h_lines);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        cv::Mat h_lines(d_lines);
+        cv::Vec2f* begin = (cv::Vec2f*)(h_lines.ptr<char>(0));
+        cv::Vec2f* end = (cv::Vec2f*)(h_lines.ptr<char>(0) + (h_lines.cols) * 2 * sizeof(float));
+        std::sort(begin, end, Vec2fComparator());
+        SANITY_CHECK(h_lines);
     }
     else
     {
@@ -2129,30 +1818,22 @@ PERF_TEST_P(Image, ImgProc_HoughLinesP, testing::Values("cv/shared/pic5.png", "s
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_lines;
-            cv::gpu::HoughLinesBuf d_buf;
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_lines;
+        cv::gpu::HoughLinesBuf d_buf;
 
+        cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+
+        TEST_CYCLE()
+        {
             cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
-            }
-
-            cv::Mat h_lines(d_lines);
-            cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
-            cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
-            std::sort(begin, end, Vec4iComparator());
-            SANITY_CHECK(h_lines);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        cv::Mat h_lines(d_lines);
+        cv::Vec4i* begin = h_lines.ptr<cv::Vec4i>();
+        cv::Vec4i* end = h_lines.ptr<cv::Vec4i>() + h_lines.cols;
+        std::sort(begin, end, Vec4iComparator());
+        SANITY_CHECK(h_lines);
     }
     else
     {
@@ -2202,30 +1883,22 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles, Combine(GPU_TYPICAL_MAT_SIZES,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_circles;
-            cv::gpu::HoughCirclesBuf d_buf;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_circles;
+        cv::gpu::HoughCirclesBuf d_buf;
 
+        cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+
+        TEST_CYCLE()
+        {
             cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-            }
-
-            cv::Mat h_circles(d_circles);
-            cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
-            cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
-            std::sort(begin, end, Vec3fComparator());
-            SANITY_CHECK(h_circles);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        cv::Mat h_circles(d_circles);
+        cv::Vec3f* begin = (cv::Vec3f*)(h_circles.ptr<char>(0));
+        cv::Vec3f* end = (cv::Vec3f*)(h_circles.ptr<char>(0) + (h_circles.cols) * 3 * sizeof(float));
+        std::sort(begin, end, Vec3fComparator());
+        SANITY_CHECK(h_circles);
     }
     else
     {
@@ -2294,36 +1967,28 @@ PERF_TEST_P(Method_Sz, ImgProc_GeneralizedHough, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_edges(edges);
+        cv::gpu::GpuMat d_dx(dx);
+        cv::gpu::GpuMat d_dy(dy);
+        cv::gpu::GpuMat d_position;
+
+        cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
+        if (method & cv::GHT_ROTATION)
         {
-            cv::gpu::GpuMat d_edges(edges);
-            cv::gpu::GpuMat d_dx(dx);
-            cv::gpu::GpuMat d_dy(dy);
-            cv::gpu::GpuMat d_position;
+            d_hough->set("maxAngle", 90.0);
+            d_hough->set("angleStep", 2.0);
+        }
 
-            cv::Ptr<cv::gpu::GeneralizedHough_GPU> d_hough = cv::gpu::GeneralizedHough_GPU::create(method);
-            if (method & cv::GHT_ROTATION)
-            {
-                d_hough->set("maxAngle", 90.0);
-                d_hough->set("angleStep", 2.0);
-            }
+        d_hough->setTemplate(cv::gpu::GpuMat(templ));
 
-            d_hough->setTemplate(cv::gpu::GpuMat(templ));
+        d_hough->detect(d_edges, d_dx, d_dy, d_position);
 
+        TEST_CYCLE()
+        {
             d_hough->detect(d_edges, d_dx, d_dy, d_position);
-
-            TEST_CYCLE()
-            {
-                d_hough->detect(d_edges, d_dx, d_dy, d_position);
-            }
-
-            GPU_SANITY_CHECK(d_position);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_position);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_labeling.cpp b/modules/gpu/perf/perf_labeling.cpp
index 0fb81aa13..3b10ba3be 100644
--- a/modules/gpu/perf/perf_labeling.cpp
+++ b/modules/gpu/perf/perf_labeling.cpp
@@ -108,30 +108,22 @@ PERF_TEST_P(Image, Labeling_ConnectedComponents, Values<string>("gpu/labeling/al
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat mask;
+        mask.create(image.rows, image.cols, CV_8UC1);
+
+        cv::gpu::GpuMat components;
+        components.create(image.rows, image.cols, CV_32SC1);
+
+        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+
+        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat mask;
-            mask.create(image.rows, image.cols, CV_8UC1);
-
-            cv::gpu::GpuMat components;
-            components.create(image.rows, image.cols, CV_32SC1);
-
-            cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
-
-            ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
-
-            TEST_CYCLE()
-            {
-                cv::gpu::labelComponents(mask, components);
-            }
-
-            GPU_SANITY_CHECK(components);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+            cv::gpu::labelComponents(mask, components);
         }
+
+        GPU_SANITY_CHECK(components);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_matop.cpp b/modules/gpu/perf/perf_matop.cpp
index 97f6dd1d1..b6d4a110f 100644
--- a/modules/gpu/perf/perf_matop.cpp
+++ b/modules/gpu/perf/perf_matop.cpp
@@ -20,24 +20,16 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV_8
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(size, type);
+        cv::gpu::GpuMat d_src(size, type);
 
+        d_src.setTo(val);
+
+        TEST_CYCLE()
+        {
             d_src.setTo(val);
-
-            TEST_CYCLE()
-            {
-                d_src.setTo(val);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -75,25 +67,17 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_SetToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Value
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
 
+        d_src.setTo(val, d_mask);
+
+        TEST_CYCLE()
+        {
             d_src.setTo(val, d_mask);
-
-            TEST_CYCLE()
-            {
-                d_src.setTo(val, d_mask);
-            }
-
-            GPU_SANITY_CHECK(d_src);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_src);
     }
     else
     {
@@ -127,26 +111,18 @@ PERF_TEST_P(Sz_Depth_Cn, MatOp_CopyToMasked, Combine(GPU_TYPICAL_MAT_SIZES, Valu
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_mask(mask);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_mask(mask);
+        cv::gpu::GpuMat d_dst;
 
+        d_src.copyTo(d_dst, d_mask);
+
+        TEST_CYCLE()
+        {
             d_src.copyTo(d_dst, d_mask);
-
-            TEST_CYCLE()
-            {
-                d_src.copyTo(d_dst, d_mask);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
@@ -179,25 +155,17 @@ PERF_TEST_P(Sz_2Depth, MatOp_ConvertTo, Combine(GPU_TYPICAL_MAT_SIZES, Values(CV
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_src(src);
-            cv::gpu::GpuMat d_dst;
+        cv::gpu::GpuMat d_src(src);
+        cv::gpu::GpuMat d_dst;
 
+        d_src.convertTo(d_dst, depth2, 0.5, 1.0);
+
+        TEST_CYCLE()
+        {
             d_src.convertTo(d_dst, depth2, 0.5, 1.0);
-
-            TEST_CYCLE()
-            {
-                d_src.convertTo(d_dst, depth2, 0.5, 1.0);
-            }
-
-            GPU_SANITY_CHECK(d_dst);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_dst);
     }
     else
     {
diff --git a/modules/gpu/perf/perf_objdetect.cpp b/modules/gpu/perf/perf_objdetect.cpp
index 4c74bba36..6d040ac02 100644
--- a/modules/gpu/perf/perf_objdetect.cpp
+++ b/modules/gpu/perf/perf_objdetect.cpp
@@ -19,24 +19,16 @@ PERF_TEST_P(Image, ObjDetect_HOG, Values<string>("gpu/hog/road.png"))
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_img(img);
+
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
+        d_hog.detectMultiScale(d_img, found_locations);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_img(img);
-
-            cv::gpu::HOGDescriptor d_hog;
-            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-
             d_hog.detectMultiScale(d_img, found_locations);
-
-            TEST_CYCLE()
-            {
-                d_hog.detectMultiScale(d_img, found_locations);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -69,24 +61,16 @@ PERF_TEST_P(HOG, CalTech, Values<string>("gpu/caltech/image_00000009_0.png", "gp
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_img(img);
+
+        cv::gpu::HOGDescriptor d_hog;
+        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+
+        d_hog.detectMultiScale(d_img, found_locations);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_img(img);
-
-            cv::gpu::HOGDescriptor d_hog;
-            d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-
             d_hog.detectMultiScale(d_img, found_locations);
-
-            TEST_CYCLE()
-            {
-                d_hog.detectMultiScale(d_img, found_locations);
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
     }
     else
@@ -119,28 +103,20 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_HaarClassifier,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_objects_buffer;
+
+        d_cascade.detectMultiScale(d_img, d_objects_buffer);
+
+        TEST_CYCLE()
         {
-            cv::gpu::CascadeClassifier_GPU d_cascade;
-            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_objects_buffer;
-
             d_cascade.detectMultiScale(d_img, d_objects_buffer);
-
-            TEST_CYCLE()
-            {
-                d_cascade.detectMultiScale(d_img, d_objects_buffer);
-            }
-
-            GPU_SANITY_CHECK(d_objects_buffer);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_objects_buffer);
     }
     else
     {
@@ -171,28 +147,20 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::CascadeClassifier_GPU d_cascade;
+        ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
+
+        cv::gpu::GpuMat d_img(img);
+        cv::gpu::GpuMat d_gpu_rects;
+
+        d_cascade.detectMultiScale(d_img, d_gpu_rects);
+
+        TEST_CYCLE()
         {
-            cv::gpu::CascadeClassifier_GPU d_cascade;
-            ASSERT_TRUE(d_cascade.load(perf::TestBase::getDataPath(GetParam().second)));
-
-            cv::gpu::GpuMat d_img(img);
-            cv::gpu::GpuMat d_gpu_rects;
-
             d_cascade.detectMultiScale(d_img, d_gpu_rects);
-
-            TEST_CYCLE()
-            {
-                d_cascade.detectMultiScale(d_img, d_gpu_rects);
-            }
-
-            GPU_SANITY_CHECK(d_gpu_rects);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_gpu_rects);
     }
     else
     {
@@ -212,4 +180,4 @@ PERF_TEST_P(ImageAndCascade, ObjDetect_LBPClassifier,
     }
 }
 
-} // namespace
+} // namespace
\ No newline at end of file
diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 1d3ebe837..9645beeaf 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -60,36 +60,28 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
 
 RUN_GPU(SCascadeTest, detect)
 {
-    try
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(1);
+
+    cascade.detect(colored, rois, objectBoxes);
+
+    TEST_CYCLE()
     {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(1);
-
         cascade.detect(colored, rois, objectBoxes);
-
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detect)
@@ -126,45 +118,37 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
 
 RUN_GPU(SCascadeTestRoi, detectInRoi)
 {
-    try
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+
+    int nroi = GET_PARAM(2);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
     {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
+        cv::Rect r = getFromTable(rng(10));
+        cv::gpu::GpuMat sub(rois, r);
+        sub.setTo(1);
+    }
 
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-
-        int nroi = GET_PARAM(2);
-        cv::RNG rng;
-        for (int i = 0; i < nroi; ++i)
-        {
-            cv::Rect r = getFromTable(rng(10));
-            cv::gpu::GpuMat sub(rois, r);
-            sub.setTo(1);
-        }
+    cascade.detect(colored, rois, objectBoxes);
 
+    TEST_CYCLE()
+    {
         cascade.detect(colored, rois, objectBoxes);
-
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTestRoi, detectInRoi)
@@ -179,41 +163,33 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
 
 RUN_GPU(SCascadeTestRoi, detectEachRoi)
 {
-    try
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+
+    int idx = GET_PARAM(2);
+    cv::Rect r = getFromTable(idx);
+    cv::gpu::GpuMat sub(rois, r);
+    sub.setTo(1);
+
+    cascade.detect(colored, rois, objectBoxes);
+
+    TEST_CYCLE()
     {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        cv::gpu::GpuMat objectBoxes(1, 16384 * 20, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-
-        int idx = GET_PARAM(2);
-        cv::Rect r = getFromTable(idx);
-        cv::gpu::GpuMat sub(rois, r);
-        sub.setTo(1);
-
         cascade.detect(colored, rois, objectBoxes);
-
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes);
-        }
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTestRoi, detectEachRoi)
@@ -233,44 +209,36 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
 
 RUN_GPU(SCascadeTest, detectOnIntegral)
 {
-    try
+    cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
+
+    cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
     {
-        cv::FileStorage fsi(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-        ASSERT_TRUE(fsi.isOpened());
+        cv::Mat channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
+        cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
+    }
 
-        cv::gpu::GpuMat hogluv(121 * 10, 161, CV_32SC1);
-        for (int i = 0; i < 10; ++i)
-        {
-            cv::Mat channel;
-            fsi[std::string("channel") + itoa(i)] >> channel;
-            cv::gpu::GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-            gchannel.upload(channel);
-        }
+    cv::gpu::SCascade cascade;
 
-        cv::gpu::SCascade cascade;
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+    rois.setTo(1);
 
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-        rois.setTo(1);
+    cascade.detect(hogluv, rois, objectBoxes);
 
+    TEST_CYCLE()
+    {
         cascade.detect(hogluv, rois, objectBoxes);
-
-        TEST_CYCLE()
-        {
-            cascade.detect(hogluv, rois, objectBoxes);
-        }
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detectOnIntegral)
@@ -283,42 +251,34 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
 
 RUN_GPU(SCascadeTest, detectStream)
 {
-    try
+    cv::Mat cpu = readImage (GET_PARAM(1));
+    ASSERT_FALSE(cpu.empty());
+    cv::gpu::GpuMat colored(cpu);
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(1);
+
+    cv::gpu::Stream s;
+
+    cascade.detect(colored, rois, objectBoxes, s);
+
+    TEST_CYCLE()
     {
-        cv::Mat cpu = readImage (GET_PARAM(1));
-        ASSERT_FALSE(cpu.empty());
-        cv::gpu::GpuMat colored(cpu);
-
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(0)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        cv::gpu::GpuMat objectBoxes(1, 10000 * sizeof(cv::gpu::SCascade::Detection), CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(1);
-
-        cv::gpu::Stream s;
-
         cascade.detect(colored, rois, objectBoxes, s);
-
-        TEST_CYCLE()
-        {
-            cascade.detect(colored, rois, objectBoxes, s);
-        }
-
-    #ifdef HAVE_CUDA
-        cudaDeviceSynchronize();
-    #endif
-
-        SANITY_CHECK(sortDetections(objectBoxes));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+#ifdef HAVE_CUDA
+    cudaDeviceSynchronize();
+#endif
+
+    SANITY_CHECK(sortDetections(objectBoxes));
 }
 
 NO_CPU(SCascadeTest, detectStream)
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 661050e0e..5afe0d15f 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -36,31 +36,23 @@ PERF_TEST_P(ImagePair, Video_BroxOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
+
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+        d_flow(d_frame0, d_frame1, d_u, d_v);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
             d_flow(d_frame0, d_frame1, d_u, d_v);
-
-            TEST_CYCLE()
-            {
-                d_flow(d_frame0, d_frame1, d_u, d_v);
-            }
-
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -85,39 +77,31 @@ PERF_TEST_P(ImagePair, Video_InterpolateFrames,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_fu, d_fv;
+        cv::gpu::GpuMat d_bu, d_bv;
+
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+        d_flow(d_frame0, d_frame1, d_fu, d_fv);
+        d_flow(d_frame1, d_frame0, d_bu, d_bv);
+
+        cv::gpu::GpuMat d_newFrame;
+        cv::gpu::GpuMat d_buf;
+
+        cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_fu, d_fv;
-            cv::gpu::GpuMat d_bu, d_bv;
-
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-            d_flow(d_frame0, d_frame1, d_fu, d_fv);
-            d_flow(d_frame1, d_frame0, d_bu, d_bv);
-
-            cv::gpu::GpuMat d_newFrame;
-            cv::gpu::GpuMat d_buf;
-
             cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::interpolateFrames(d_frame0, d_frame1, d_fu, d_fv, d_bu, d_bv, 0.5f, d_newFrame, d_buf);
-            }
-
-            GPU_SANITY_CHECK(d_fu);
-            GPU_SANITY_CHECK(d_fv);
-            GPU_SANITY_CHECK(d_bu);
-            GPU_SANITY_CHECK(d_bv);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_fu);
+        GPU_SANITY_CHECK(d_fv);
+        GPU_SANITY_CHECK(d_bu);
+        GPU_SANITY_CHECK(d_bv);
     }
     else
     {
@@ -142,35 +126,27 @@ PERF_TEST_P(ImagePair, Video_CreateOpticalFlowNeedleMap,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
+
+        cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                        10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+        d_flow(d_frame0, d_frame1, d_u, d_v);
+
+        cv::gpu::GpuMat d_vertex, d_colors;
+
+        cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::BroxOpticalFlow d_flow(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                            10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-            d_flow(d_frame0, d_frame1, d_u, d_v);
-
-            cv::gpu::GpuMat d_vertex, d_colors;
-
             cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors);
-            }
-
-            GPU_SANITY_CHECK(d_vertex);
-            GPU_SANITY_CHECK(d_colors);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_vertex);
+        GPU_SANITY_CHECK(d_colors);
     }
     else
     {
@@ -194,27 +170,19 @@ PERF_TEST_P(Image_MinDistance, Video_GoodFeaturesToTrack,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
+
+        cv::gpu::GpuMat d_image(image);
+        cv::gpu::GpuMat d_pts;
+
+        d_detector(d_image, d_pts);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GoodFeaturesToTrackDetector_GPU d_detector(8000, 0.01, minDistance);
-
-            cv::gpu::GpuMat d_image(image);
-            cv::gpu::GpuMat d_pts;
-
             d_detector(d_image, d_pts);
-
-            TEST_CYCLE()
-            {
-                d_detector(d_image, d_pts);
-            }
-
-            GPU_SANITY_CHECK(d_pts);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_pts);
     }
     else
     {
@@ -270,34 +238,26 @@ PERF_TEST_P(ImagePair_Gray_NPts_WinSz_Levels_Iters, Video_PyrLKOpticalFlowSparse
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
+
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = cv::Size(winSize, winSize);
+        d_pyrLK.maxLevel = levels - 1;
+        d_pyrLK.iters = iters;
+
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_nextPts;
+        cv::gpu::GpuMat d_status;
+
+        d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_pts(pts.reshape(2, 1));
-
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = cv::Size(winSize, winSize);
-            d_pyrLK.maxLevel = levels - 1;
-            d_pyrLK.iters = iters;
-
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_nextPts;
-            cv::gpu::GpuMat d_status;
-
             d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-
-            TEST_CYCLE()
-            {
-                d_pyrLK.sparse(d_frame0, d_frame1, d_pts, d_nextPts, d_status);
-            }
-
-            GPU_SANITY_CHECK(d_status);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_status);
     }
     else
     {
@@ -345,33 +305,25 @@ PERF_TEST_P(ImagePair_WinSz_Levels_Iters, Video_PyrLKOpticalFlowDense, Combine(
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
+
+        cv::gpu::PyrLKOpticalFlow d_pyrLK;
+        d_pyrLK.winSize = cv::Size(winSize, winSize);
+        d_pyrLK.maxLevel = levels - 1;
+        d_pyrLK.iters = iters;
+
+        d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::PyrLKOpticalFlow d_pyrLK;
-            d_pyrLK.winSize = cv::Size(winSize, winSize);
-            d_pyrLK.maxLevel = levels - 1;
-            d_pyrLK.iters = iters;
-
             d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
-
-            TEST_CYCLE()
-            {
-                d_pyrLK.dense(d_frame0, d_frame1, d_u, d_v);
-            }
-
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -403,37 +355,29 @@ PERF_TEST_P(ImagePair, Video_FarnebackOpticalFlow,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_u;
+        cv::gpu::GpuMat d_v;
+
+        cv::gpu::FarnebackOpticalFlow d_farneback;
+        d_farneback.numLevels = numLevels;
+        d_farneback.pyrScale = pyrScale;
+        d_farneback.winSize = winSize;
+        d_farneback.numIters = numIters;
+        d_farneback.polyN = polyN;
+        d_farneback.polySigma = polySigma;
+        d_farneback.flags = flags;
+
+        d_farneback(d_frame0, d_frame1, d_u, d_v);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_u;
-            cv::gpu::GpuMat d_v;
-
-            cv::gpu::FarnebackOpticalFlow d_farneback;
-            d_farneback.numLevels = numLevels;
-            d_farneback.pyrScale = pyrScale;
-            d_farneback.winSize = winSize;
-            d_farneback.numIters = numIters;
-            d_farneback.polyN = polyN;
-            d_farneback.polySigma = polySigma;
-            d_farneback.flags = flags;
-
             d_farneback(d_frame0, d_frame1, d_u, d_v);
-
-            TEST_CYCLE()
-            {
-                d_farneback(d_frame0, d_frame1, d_u, d_v);
-            }
-
-            GPU_SANITY_CHECK(d_u);
-            GPU_SANITY_CHECK(d_v);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_u);
+        GPU_SANITY_CHECK(d_v);
     }
     else
     {
@@ -466,30 +410,22 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowDual_TVL1,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_flowx;
+        cv::gpu::GpuMat d_flowy;
+
+        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+
+        d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_flowx;
-            cv::gpu::GpuMat d_flowy;
-
-            cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-
             d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
-
-            TEST_CYCLE()
-            {
-                d_alg(d_frame0, d_frame1, d_flowx, d_flowy);
-            }
-
-            GPU_SANITY_CHECK(d_flowx);
-            GPU_SANITY_CHECK(d_flowy);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_flowx);
+        GPU_SANITY_CHECK(d_flowy);
     }
     else
     {
@@ -546,27 +482,19 @@ PERF_TEST_P(ImagePair, Video_OpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
-        {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_velx, d_vely, buf;
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely, buf;
 
+        cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
+
+        TEST_CYCLE()
+        {
             cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-
-            TEST_CYCLE()
-            {
-                cv::gpu::calcOpticalFlowBM(d_frame0, d_frame1, block_size, shift_size, max_range, false, d_velx, d_vely, buf);
-            }
-
-            GPU_SANITY_CHECK(d_velx);
-            GPU_SANITY_CHECK(d_vely);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
     }
     else
     {
@@ -601,29 +529,21 @@ PERF_TEST_P(ImagePair, Video_FastOpticalFlowBM,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame0(frame0);
+        cv::gpu::GpuMat d_frame1(frame1);
+        cv::gpu::GpuMat d_velx, d_vely;
+
+        cv::gpu::FastOpticalFlowBM fastBM;
+
+        fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
+
+        TEST_CYCLE()
         {
-            cv::gpu::GpuMat d_frame0(frame0);
-            cv::gpu::GpuMat d_frame1(frame1);
-            cv::gpu::GpuMat d_velx, d_vely;
-
-            cv::gpu::FastOpticalFlowBM fastBM;
-
             fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
-
-            TEST_CYCLE()
-            {
-                fastBM(d_frame0, d_frame1, d_velx, d_vely, max_range.width, block_size.width);
-            }
-
-            GPU_SANITY_CHECK(d_velx);
-            GPU_SANITY_CHECK(d_vely);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_velx);
+        GPU_SANITY_CHECK(d_vely);
     }
     else
     {
@@ -661,29 +581,21 @@ PERF_TEST_P(Video, DISABLED_Video_FGDStatModel, Values("gpu/video/768x576.avi",
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame(frame);
+
+        cv::gpu::FGDStatModel d_model(4);
+        d_model.create(d_frame);
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame(frame);
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            cv::gpu::FGDStatModel d_model(4);
-            d_model.create(d_frame);
+            d_frame.upload(frame);
 
-            for (int i = 0; i < 10; ++i)
-            {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_model.update(d_frame);
-                stopTimer();
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+            startTimer(); next();
+            d_model.update(d_frame);
+            stopTimer();
         }
     }
     else
@@ -737,40 +649,32 @@ PERF_TEST_P(Video_Cn_LearningRate, DISABLED_Video_MOG,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG_GPU d_mog;
+        cv::gpu::GpuMat d_foreground;
+
+        d_mog(d_frame, d_foreground, learningRate);
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::MOG_GPU d_mog;
-            cv::gpu::GpuMat d_foreground;
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            d_mog(d_frame, d_foreground, learningRate);
-
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_mog(d_frame, d_foreground, learningRate);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_mog(d_frame, d_foreground, learningRate);
+            stopTimer();
         }
     }
     else
@@ -833,40 +737,32 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_MOG2,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::MOG2_GPU d_mog2;
+        cv::gpu::GpuMat d_foreground;
+
+        d_mog2(d_frame, d_foreground);
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::MOG2_GPU d_mog2;
-            cv::gpu::GpuMat d_foreground;
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            d_mog2(d_frame, d_foreground);
-
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_mog2(d_frame, d_foreground);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_mog2(d_frame, d_foreground);
+            stopTimer();
         }
     }
     else
@@ -914,47 +810,39 @@ PERF_TEST_P(Video_Cn, Video_MOG2GetBackgroundImage,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame;
+        cv::gpu::MOG2_GPU d_mog2;
+        cv::gpu::GpuMat d_foreground;
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame;
-            cv::gpu::MOG2_GPU d_mog2;
-            cv::gpu::GpuMat d_foreground;
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                d_mog2(d_frame, d_foreground);
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
 
-            cv::gpu::GpuMat d_background;
+            d_frame.upload(frame);
+
+            d_mog2(d_frame, d_foreground);
+        }
+
+        cv::gpu::GpuMat d_background;
+        d_mog2.getBackgroundImage(d_background);
+
+        TEST_CYCLE()
+        {
             d_mog2.getBackgroundImage(d_background);
-
-            TEST_CYCLE()
-            {
-                d_mog2.getBackgroundImage(d_background);
-            }
-
-            GPU_SANITY_CHECK(d_background);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_background);
     }
     else
     {
@@ -1019,40 +907,32 @@ PERF_TEST_P(Video_Cn, DISABLED_Video_VIBE,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::VIBE_GPU d_vibe;
+        cv::gpu::GpuMat d_foreground;
+
+        d_vibe(d_frame, d_foreground);
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::VIBE_GPU d_vibe;
-            cv::gpu::GpuMat d_foreground;
+            cap >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            d_vibe(d_frame, d_foreground);
-
-            for (int i = 0; i < 10; ++i)
+            if (cn != 3)
             {
-                cap >> frame;
-                ASSERT_FALSE(frame.empty());
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_vibe(d_frame, d_foreground);
-                stopTimer();
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_vibe(d_frame, d_foreground);
+            stopTimer();
         }
     }
     else
@@ -1092,47 +972,39 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::GpuMat d_frame(frame);
+        cv::gpu::GpuMat d_fgmask;
+
+        cv::gpu::GMG_GPU d_gmg;
+        d_gmg.maxFeatures = maxFeatures;
+
+        d_gmg(d_frame, d_fgmask);
+
+        for (int i = 0; i < 150; ++i)
         {
-            cv::gpu::GpuMat d_frame(frame);
-            cv::gpu::GpuMat d_fgmask;
-
-            cv::gpu::GMG_GPU d_gmg;
-            d_gmg.maxFeatures = maxFeatures;
-
-            d_gmg(d_frame, d_fgmask);
-
-            for (int i = 0; i < 150; ++i)
+            cap >> frame;
+            if (frame.empty())
             {
+                cap.release();
+                cap.open(inputFile);
                 cap >> frame;
-                if (frame.empty())
-                {
-                    cap.release();
-                    cap.open(inputFile);
-                    cap >> frame;
-                }
-
-                if (cn != 3)
-                {
-                    cv::Mat temp;
-                    if (cn == 1)
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                    else
-                        cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
-                    cv::swap(temp, frame);
-                }
-
-                d_frame.upload(frame);
-
-                startTimer(); next();
-                d_gmg(d_frame, d_fgmask);
-                stopTimer();
             }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+
+            if (cn != 3)
+            {
+                cv::Mat temp;
+                if (cn == 1)
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+                else
+                    cv::cvtColor(frame, temp, cv::COLOR_BGR2BGRA);
+                cv::swap(temp, frame);
+            }
+
+            d_frame.upload(frame);
+
+            startTimer(); next();
+            d_gmg(d_frame, d_fgmask);
+            stopTimer();
         }
     }
     else
@@ -1194,31 +1066,23 @@ PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::VideoWriter_GPU d_writer;
+
+        cv::gpu::GpuMat d_frame;
+
+        for (int i = 0; i < 10; ++i)
         {
-            cv::gpu::VideoWriter_GPU d_writer;
+            reader >> frame;
+            ASSERT_FALSE(frame.empty());
 
-            cv::gpu::GpuMat d_frame;
+            d_frame.upload(frame);
 
-            for (int i = 0; i < 10; ++i)
-            {
-                reader >> frame;
-                ASSERT_FALSE(frame.empty());
+            if (!d_writer.isOpened())
+                d_writer.open(outputFile, frame.size(), FPS);
 
-                d_frame.upload(frame);
-
-                if (!d_writer.isOpened())
-                    d_writer.open(outputFile, frame.size(), FPS);
-
-                startTimer(); next();
-                d_writer.write(d_frame);
-                stopTimer();
-            }
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
+            startTimer(); next();
+            d_writer.write(d_frame);
+            stopTimer();
         }
     }
     else
@@ -1251,27 +1115,19 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
 
     if (PERF_RUN_GPU())
     {
-        try
+        cv::gpu::VideoReader_GPU d_reader(inputFile);
+        ASSERT_TRUE( d_reader.isOpened() );
+
+        cv::gpu::GpuMat d_frame;
+
+        d_reader.read(d_frame);
+
+        TEST_CYCLE_N(10)
         {
-            cv::gpu::VideoReader_GPU d_reader(inputFile);
-            ASSERT_TRUE( d_reader.isOpened() );
-
-            cv::gpu::GpuMat d_frame;
-
             d_reader.read(d_frame);
-
-            TEST_CYCLE_N(10)
-            {
-                d_reader.read(d_frame);
-            }
-
-            GPU_SANITY_CHECK(d_frame);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
         }
+
+        GPU_SANITY_CHECK(d_frame);
     }
     else
     {
diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp
index 43c92ce1e..7873563ce 100644
--- a/modules/gpu/test/nvidia/main_nvidia.cpp
+++ b/modules/gpu/test/nvidia/main_nvidia.cpp
@@ -276,8 +276,6 @@ static void devNullOutput(const std::string& msg)
     (void)msg;
 }
 
-}
-
 bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path.c_str();
@@ -294,6 +292,8 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
     return testListerII.invoke();
 }
 
+}
+
 bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path;
@@ -439,4 +439,4 @@ bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel out
     return testListerVisualize.invoke();
 }
 
-#endif /* CUDA_DISABLER */
+#endif /* CUDA_DISABLER */
\ No newline at end of file
diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp
index 4a53c6093..a294a3df9 100644
--- a/modules/gpu/test/test_calib3d.cpp
+++ b/modules/gpu/test/test_calib3d.cpp
@@ -62,28 +62,20 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBM, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-        cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
-        cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat disp_gold   = readImage("stereobm/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoBM_GPU bm(0, 128, 19);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoBM_GPU bm(0, 128, 19);
+    cv::gpu::GpuMat disp;
 
-        bm(loadMat(left_image), loadMat(right_image), disp);
+    bm(loadMat(left_image), loadMat(right_image), disp);
 
-        EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, disp, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBM, ALL_DEVICES);
@@ -105,31 +97,23 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoBeliefPropagation, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("stereobp/aloe-L.png");
-        cv::Mat right_image = readImage("stereobp/aloe-R.png");
-        cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    cv::Mat left_image  = readImage("stereobp/aloe-L.png");
+    cv::Mat right_image = readImage("stereobp/aloe-R.png");
+    cv::Mat disp_gold   = readImage("stereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoBeliefPropagation bp(64, 8, 2, 25, 0.1f, 15, 1, CV_16S);
+    cv::gpu::GpuMat disp;
 
-        bp(loadMat(left_image), loadMat(right_image), disp);
+    bp(loadMat(left_image), loadMat(right_image), disp);
 
-        cv::Mat h_disp(disp);
-        h_disp.convertTo(h_disp, disp_gold.depth());
+    cv::Mat h_disp(disp);
+    h_disp.convertTo(h_disp, disp_gold.depth());
 
-        EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, h_disp, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoBeliefPropagation, ALL_DEVICES);
@@ -151,37 +135,29 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(StereoConstantSpaceBP, Regression)
 {
-    try
-    {
-        cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
-        cv::Mat right_image = readImage("csstereobp/aloe-R.png");
+    cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
+    cv::Mat right_image = readImage("csstereobp/aloe-R.png");
 
-        cv::Mat disp_gold;
+    cv::Mat disp_gold;
 
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
-        else
-            disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        disp_gold = readImage("csstereobp/aloe-disp.png", cv::IMREAD_GRAYSCALE);
+    else
+        disp_gold = readImage("csstereobp/aloe-disp_CC1X.png", cv::IMREAD_GRAYSCALE);
 
-        ASSERT_FALSE(left_image.empty());
-        ASSERT_FALSE(right_image.empty());
-        ASSERT_FALSE(disp_gold.empty());
+    ASSERT_FALSE(left_image.empty());
+    ASSERT_FALSE(right_image.empty());
+    ASSERT_FALSE(disp_gold.empty());
 
-        cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
-        cv::gpu::GpuMat disp;
+    cv::gpu::StereoConstantSpaceBP csbp(128, 16, 4, 4);
+    cv::gpu::GpuMat disp;
 
-        csbp(loadMat(left_image), loadMat(right_image), disp);
+    csbp(loadMat(left_image), loadMat(right_image), disp);
 
-        cv::Mat h_disp(disp);
-        h_disp.convertTo(h_disp, disp_gold.depth());
+    cv::Mat h_disp(disp);
+    h_disp.convertTo(h_disp, disp_gold.depth());
 
-        EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(disp_gold, h_disp, 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, StereoConstantSpaceBP, ALL_DEVICES);
@@ -203,40 +179,32 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(TransformPoints, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
+
+    ASSERT_EQ(src.size(), dst.size());
+    ASSERT_EQ(src.type(), dst.type());
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat rot;
+    cv::Rodrigues(rvec, rot);
+
+    for (int i = 0; i < h_dst.cols; ++i)
     {
-        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+        cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::transformPoints(loadMat(src), rvec, tvec, dst);
+        cv::Point3f p = src.at<cv::Point3f>(0, i);
+        cv::Point3f res_gold(
+                rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
+                rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
+                rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
 
-        ASSERT_EQ(src.size(), dst.size());
-        ASSERT_EQ(src.type(), dst.type());
-
-        cv::Mat h_dst(dst);
-
-        cv::Mat rot;
-        cv::Rodrigues(rvec, rot);
-
-        for (int i = 0; i < h_dst.cols; ++i)
-        {
-            cv::Point3f res = h_dst.at<cv::Point3f>(0, i);
-
-            cv::Point3f p = src.at<cv::Point3f>(0, i);
-            cv::Point3f res_gold(
-                    rot.at<float>(0, 0) * p.x + rot.at<float>(0, 1) * p.y + rot.at<float>(0, 2) * p.z + tvec.at<float>(0, 0),
-                    rot.at<float>(1, 0) * p.x + rot.at<float>(1, 1) * p.y + rot.at<float>(1, 2) * p.z + tvec.at<float>(0, 1),
-                    rot.at<float>(2, 0) * p.x + rot.at<float>(2, 1) * p.y + rot.at<float>(2, 2) * p.z + tvec.at<float>(0, 2));
-
-            ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_POINT3_NEAR(res_gold, res, 1e-5);
     }
 }
 
@@ -259,42 +227,34 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(ProjectPoints, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
+    cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+    camera_mat.at<float>(0, 1) = 0.f;
+    camera_mat.at<float>(1, 0) = 0.f;
+    camera_mat.at<float>(2, 0) = 0.f;
+    camera_mat.at<float>(2, 1) = 0.f;
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
+
+    ASSERT_EQ(1, dst.rows);
+    ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
+
+    std::vector<cv::Point2f> dst_gold;
+    cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
+
+    ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
+
+    cv::Mat h_dst(dst);
+
+    for (size_t i = 0; i < dst_gold.size(); ++i)
     {
-        cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
-        cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat tvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-        camera_mat.at<float>(0, 1) = 0.f;
-        camera_mat.at<float>(1, 0) = 0.f;
-        camera_mat.at<float>(2, 0) = 0.f;
-        camera_mat.at<float>(2, 1) = 0.f;
+        cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
+        cv::Point2f res_gold = dst_gold[i];
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::projectPoints(loadMat(src), rvec, tvec, camera_mat, cv::Mat(), dst);
-
-        ASSERT_EQ(1, dst.rows);
-        ASSERT_EQ(MatType(CV_32FC2), MatType(dst.type()));
-
-        std::vector<cv::Point2f> dst_gold;
-        cv::projectPoints(src, rvec, tvec, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), dst_gold);
-
-        ASSERT_EQ(dst_gold.size(), static_cast<size_t>(dst.cols));
-
-        cv::Mat h_dst(dst);
-
-        for (size_t i = 0; i < dst_gold.size(); ++i)
-        {
-            cv::Point2f res = h_dst.at<cv::Point2f>(0, (int)i);
-            cv::Point2f res_gold = dst_gold[i];
-
-            ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_LE(cv::norm(res_gold - res) / cv::norm(res_gold), 1e-3f);
     }
 }
 
@@ -317,36 +277,28 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(SolvePnPRansac, Accuracy)
 {
-    try
-    {
-        cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
-        cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
-        camera_mat.at<float>(0, 1) = 0.f;
-        camera_mat.at<float>(1, 0) = 0.f;
-        camera_mat.at<float>(2, 0) = 0.f;
-        camera_mat.at<float>(2, 1) = 0.f;
+    cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
+    cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
+    camera_mat.at<float>(0, 1) = 0.f;
+    camera_mat.at<float>(1, 0) = 0.f;
+    camera_mat.at<float>(2, 0) = 0.f;
+    camera_mat.at<float>(2, 1) = 0.f;
 
-        std::vector<cv::Point2f> image_vec;
-        cv::Mat rvec_gold;
-        cv::Mat tvec_gold;
-        rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
-        cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
+    std::vector<cv::Point2f> image_vec;
+    cv::Mat rvec_gold;
+    cv::Mat tvec_gold;
+    rvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    tvec_gold = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
+    cv::projectPoints(object, rvec_gold, tvec_gold, camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)), image_vec);
 
-        cv::Mat rvec, tvec;
-        std::vector<int> inliers;
-        cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
-                                camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
-                                rvec, tvec, false, 200, 2.f, 100, &inliers);
+    cv::Mat rvec, tvec;
+    std::vector<int> inliers;
+    cv::gpu::solvePnPRansac(object, cv::Mat(1, (int)image_vec.size(), CV_32FC2, &image_vec[0]),
+                            camera_mat, cv::Mat(1, 8, CV_32F, cv::Scalar::all(0)),
+                            rvec, tvec, false, 200, 2.f, 100, &inliers);
 
-        ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
-        ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_LE(cv::norm(rvec - rvec_gold), 1e-3);
+    ASSERT_LE(cv::norm(tvec - tvec_gold), 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, SolvePnPRansac, ALL_DEVICES);
@@ -374,24 +326,16 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
 
 TEST_P(ReprojectImageTo3D, Accuracy)
 {
-    try
-    {
-        cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
-        cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
+    cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
+    cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
+    cv::gpu::GpuMat dst;
+    cv::gpu::reprojectImageTo3D(loadMat(disp, useRoi), dst, Q, 3);
 
-        cv::Mat dst_gold;
-        cv::reprojectImageTo3D(disp, dst_gold, Q, false);
+    cv::Mat dst_gold;
+    cv::reprojectImageTo3D(disp, dst_gold, Q, false);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp
index e350ee965..2510f564d 100644
--- a/modules/gpu/test/test_color.cpp
+++ b/modules/gpu/test/test_color.cpp
@@ -72,261 +72,165 @@ PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CvtColor, BGR2RGB)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2RGBA)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2RGBA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2BGRA)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGRA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGRA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2RGBA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2RGBA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2GRAY)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2GRAY)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, GRAY2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2GRAY)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2GRAY)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2BGR565)
@@ -334,23 +238,15 @@ TEST_P(CvtColor, BGR2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGB2BGR565)
@@ -358,23 +254,15 @@ TEST_P(CvtColor, RGB2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652BGR)
@@ -382,24 +270,16 @@ TEST_P(CvtColor, BGR5652BGR)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652RGB)
@@ -407,24 +287,16 @@ TEST_P(CvtColor, BGR5652RGB)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR565)
@@ -432,24 +304,16 @@ TEST_P(CvtColor, BGRA2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGBA2BGR565)
@@ -457,24 +321,16 @@ TEST_P(CvtColor, RGBA2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652BGRA)
@@ -482,24 +338,16 @@ TEST_P(CvtColor, BGR5652BGRA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652RGBA)
@@ -507,24 +355,16 @@ TEST_P(CvtColor, BGR5652RGBA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652RGBA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652RGBA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGR565)
@@ -532,24 +372,16 @@ TEST_P(CvtColor, GRAY2BGR565)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR565);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR565);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5652GRAY)
@@ -557,24 +389,16 @@ TEST_P(CvtColor, BGR5652GRAY)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR565);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5652GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5652GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2BGR555)
@@ -582,23 +406,15 @@ TEST_P(CvtColor, BGR2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGB2BGR555)
@@ -606,23 +422,15 @@ TEST_P(CvtColor, RGB2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552BGR)
@@ -630,24 +438,16 @@ TEST_P(CvtColor, BGR5552BGR)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552RGB)
@@ -655,24 +455,16 @@ TEST_P(CvtColor, BGR5552RGB)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGRA2BGR555)
@@ -680,24 +472,16 @@ TEST_P(CvtColor, BGRA2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGRA2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, RGBA2BGR555)
@@ -705,24 +489,16 @@ TEST_P(CvtColor, RGBA2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552BGRA)
@@ -730,24 +506,16 @@ TEST_P(CvtColor, BGR5552BGRA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552BGRA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552BGRA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552RGBA)
@@ -755,24 +523,16 @@ TEST_P(CvtColor, BGR5552RGBA)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552RGBA, 4);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552RGBA, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, GRAY2BGR555)
@@ -780,24 +540,16 @@ TEST_P(CvtColor, GRAY2BGR555)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_GRAY2BGR555);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_GRAY2BGR555);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR5552GRAY)
@@ -805,422 +557,286 @@ TEST_P(CvtColor, BGR5552GRAY)
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGR555);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR5552GRAY);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR5552GRAY);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(CvtColor, BGR2XYZ)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2XYZ)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2XYZ);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2XYZ4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGRA2XYZ4)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2XYZ, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2XYZ);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ42BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, XYZ42BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_XYZ2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_XYZ2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YCrCb)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2YCrCb)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YCrCb);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YCrCb4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2YCrCb4)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YCrCb, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb42RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YCrCb42RGBA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YCrCb2RGB, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YCrCb2RGB, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2HSV)
@@ -1228,23 +844,15 @@ TEST_P(CvtColor, BGR2HSV)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV)
@@ -1252,23 +860,15 @@ TEST_P(CvtColor, RGB2HSV)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV4)
@@ -1276,31 +876,23 @@ TEST_P(CvtColor, RGB2HSV4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HSV4)
@@ -1308,32 +900,24 @@ TEST_P(CvtColor, RGBA2HSV4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HLS)
@@ -1341,23 +925,15 @@ TEST_P(CvtColor, BGR2HLS)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS)
@@ -1365,23 +941,15 @@ TEST_P(CvtColor, RGB2HLS)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS4)
@@ -1389,31 +957,23 @@ TEST_P(CvtColor, RGB2HLS4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HLS4)
@@ -1421,32 +981,24 @@ TEST_P(CvtColor, RGBA2HLS4)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2BGR)
@@ -1454,24 +1006,16 @@ TEST_P(CvtColor, HSV2BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2RGB)
@@ -1479,24 +1023,16 @@ TEST_P(CvtColor, HSV2RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42BGR)
@@ -1504,29 +1040,21 @@ TEST_P(CvtColor, HSV42BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42BGRA)
@@ -1534,29 +1062,21 @@ TEST_P(CvtColor, HSV42BGRA)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2BGR)
@@ -1564,24 +1084,16 @@ TEST_P(CvtColor, HLS2BGR)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2RGB)
@@ -1589,24 +1101,16 @@ TEST_P(CvtColor, HLS2RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGB)
@@ -1614,29 +1118,21 @@ TEST_P(CvtColor, HLS42RGB)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGBA)
@@ -1644,30 +1140,22 @@ TEST_P(CvtColor, HLS42RGBA)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HSV_FULL)
@@ -1675,23 +1163,15 @@ TEST_P(CvtColor, BGR2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HSV_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV_FULL)
@@ -1699,23 +1179,15 @@ TEST_P(CvtColor, RGB2HSV_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HSV4_FULL)
@@ -1723,31 +1195,23 @@ TEST_P(CvtColor, RGB2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HSV4_FULL)
@@ -1755,32 +1219,24 @@ TEST_P(CvtColor, RGBA2HSV4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HSV_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HSV_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2HLS_FULL)
@@ -1788,23 +1244,15 @@ TEST_P(CvtColor, BGR2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2HLS_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS_FULL)
@@ -1812,23 +1260,15 @@ TEST_P(CvtColor, RGB2HLS_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGB2HLS4_FULL)
@@ -1836,31 +1276,23 @@ TEST_P(CvtColor, RGB2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, RGBA2HLS4_FULL)
@@ -1868,32 +1300,24 @@ TEST_P(CvtColor, RGBA2HLS4_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2HLS_FULL, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2HLS_FULL);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2BGR_FULL)
@@ -1901,24 +1325,16 @@ TEST_P(CvtColor, HSV2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2BGR_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2BGR_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV2RGB_FULL)
@@ -1926,24 +1342,16 @@ TEST_P(CvtColor, HSV2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42RGB_FULL)
@@ -1951,29 +1359,21 @@ TEST_P(CvtColor, HSV42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HSV42RGBA_FULL)
@@ -1981,29 +1381,21 @@ TEST_P(CvtColor, HSV42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HSV_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HSV2RGB_FULL, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HSV2RGB_FULL, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2BGR_FULL)
@@ -2011,24 +1403,16 @@ TEST_P(CvtColor, HLS2BGR_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2BGR_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2BGR_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS2RGB_FULL)
@@ -2036,24 +1420,16 @@ TEST_P(CvtColor, HLS2RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGB_FULL)
@@ -2061,29 +1437,21 @@ TEST_P(CvtColor, HLS42RGB_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, HLS42RGBA_FULL)
@@ -2091,374 +1459,312 @@ TEST_P(CvtColor, HLS42RGBA_FULL)
     if (depth == CV_16U)
         return;
 
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2HLS_FULL);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_HLS2RGB_FULL, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_HLS2RGB_FULL, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
 TEST_P(CvtColor, BGR2YUV)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGB2YUV)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV2BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV42BGR)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV42BGRA)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2BGR, 4);
 
-        cv::Mat channels[4];
-        cv::split(src, channels);
-        channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
-        cv::merge(channels, 4, src);
+    cv::Mat channels[4];
+    cv::split(src, channels);
+    channels[3] = cv::Mat(src.size(), depth, cv::Scalar::all(0));
+    cv::merge(channels, 4, src);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2BGR, 4);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, YUV2RGB)
 {
-    try
-    {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_YUV2RGB);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_YUV2RGB);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
 TEST_P(CvtColor, BGR2YUV4)
 {
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BGR2YUV, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGR2YUV);
 
-        cv::Mat h_dst(dst);
+    cv::Mat h_dst(dst);
 
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
 
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
 TEST_P(CvtColor, RGBA2YUV4)
 {
+    cv::Mat src;
+    cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
+
+    ASSERT_EQ(4, dst.channels());
+
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
+
+    cv::Mat h_dst(dst);
+
+    cv::Mat channels[4];
+    cv::split(h_dst, channels);
+    cv::merge(channels, 3, h_dst);
+
+    EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+}
+
+TEST_P(CvtColor, BGR2Lab)
+{
+    if (depth != CV_8U)
+        return;
+
     try
     {
-        cv::Mat src;
-        cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
+        cv::Mat src = readImage("stereobm/aloe-L.png");
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGB2YUV, 4);
+        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
 
-        ASSERT_EQ(4, dst.channels());
+        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGB2YUV);
-
-        cv::Mat h_dst(dst);
-
-        cv::Mat channels[4];
-        cv::split(h_dst, channels);
-        cv::merge(channels, 3, h_dst);
-
-        EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
+        EXPECT_MAT_NEAR(src, dst_bgr, 10);
     }
-    catch (...)
+    catch (const cv::Exception& e)
     {
-        cv::gpu::resetDevice();
-        throw;
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
     }
 }
 
-#if defined(CUDA_VERSION) && (CUDA_VERSION >= 5000)
-    TEST_P(CvtColor, BGR2Lab)
+TEST_P(CvtColor, RGB2Lab)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
     {
-        if (depth != CV_8U)
-            return;
+        cv::Mat src = readImage("stereobm/aloe-L.png");
 
-        try
-        {
-            cv::Mat src = readImage("stereobm/aloe-L.png");
+        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
 
-            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
+        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
 
-            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
-
-            EXPECT_MAT_NEAR(src, dst_bgr, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
+        EXPECT_MAT_NEAR(src, dst_bgr, 10);
     }
-
-    TEST_P(CvtColor, RGB2Lab)
+    catch (const cv::Exception& e)
     {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = readImage("stereobm/aloe-L.png");
-
-            cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
-
-            cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
-
-            EXPECT_MAT_NEAR(src, dst_bgr, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
-
-    TEST_P(CvtColor, BGR2Luv)
-    {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = img;
-
-            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
-
-            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
-
-            EXPECT_MAT_NEAR(src, dst_rgb, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
-
-    TEST_P(CvtColor, RGB2Luv)
-    {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = img;
-
-            cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
-
-            cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
-
-            EXPECT_MAT_NEAR(src, dst_rgb, 10);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
-
-    TEST_P(CvtColor, RGBA2mRGBA)
-    {
-        if (depth != CV_8U)
-            return;
-
-        try
-        {
-            cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
-
-            cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-            cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
-
-            cv::Mat dst_gold;
-            cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1);
-        }
-        catch (...)
-        {
-            cv::gpu::resetDevice();
-            throw;
-        }
-    }
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
 #endif
+    }
+}
+
+TEST_P(CvtColor, BGR2Luv)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
+    {
+        cv::Mat src = img;
+
+        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
+
+        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
+
+        EXPECT_MAT_NEAR(src, dst_rgb, 10);
+    }
+    catch (const cv::Exception& e)
+    {
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
+    }
+}
+
+TEST_P(CvtColor, RGB2Luv)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
+    {
+        cv::Mat src = img;
+
+        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
+
+        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
+
+        EXPECT_MAT_NEAR(src, dst_rgb, 10);
+    }
+    catch (const cv::Exception& e)
+    {
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
+    }
+}
+
+TEST_P(CvtColor, RGBA2mRGBA)
+{
+    if (depth != CV_8U)
+        return;
+
+    try
+    {
+        cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
+
+        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
+
+        cv::Mat dst_gold;
+        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 1);
+    }
+    catch (const cv::Exception& e)
+    {
+        (void)e;
+#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
+        ASSERT_EQ(CV_StsBadFlag, e.code);
+#else
+        FAIL();
+#endif
+    }
+}
 
 TEST_P(CvtColor, BayerBG2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerBG2BGR4)
@@ -2466,30 +1772,22 @@ TEST_P(CvtColor, BayerBG2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerBG2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerBG2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGB2BGR)
@@ -2497,23 +1795,15 @@ TEST_P(CvtColor, BayerGB2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGB2BGR4)
@@ -2521,29 +1811,21 @@ TEST_P(CvtColor, BayerGB2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGB2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGB2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerRG2BGR)
@@ -2551,23 +1833,15 @@ TEST_P(CvtColor, BayerRG2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerRG2BGR4)
@@ -2575,29 +1849,21 @@ TEST_P(CvtColor, BayerRG2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerRG2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerRG2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGR2BGR)
@@ -2605,23 +1871,15 @@ TEST_P(CvtColor, BayerGR2BGR)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 TEST_P(CvtColor, BayerGR2BGR4)
@@ -2629,29 +1887,21 @@ TEST_P(CvtColor, BayerGR2BGR4)
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_BayerGR2BGR, 4);
 
-        ASSERT_EQ(4, dst.channels());
+    ASSERT_EQ(4, dst.channels());
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BayerGR2BGR);
 
-        cv::Mat dst4(dst);
-        cv::Mat dst3;
-        cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
+    cv::Mat dst4(dst);
+    cv::Mat dst3;
+    cv::cvtColor(dst4, dst3, cv::COLOR_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CvtColor, testing::Combine(
@@ -2681,26 +1931,18 @@ PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(SwapChannels, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
 
-        const int dstOrder[] = {2, 1, 0, 3};
-        cv::gpu::swapChannels(d_src, dstOrder);
+    const int dstOrder[] = {2, 1, 0, 3};
+    cv::gpu::swapChannels(d_src, dstOrder);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_BGRA2RGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, d_src, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp
index 7c9bb3554..0efd9ec68 100644
--- a/modules/gpu/test/test_copy_make_border.cpp
+++ b/modules/gpu/test/test_copy_make_border.cpp
@@ -71,24 +71,16 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
 
 TEST_P(CopyMakeBorder, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar val = randomScalar(0, 255);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar val = randomScalar(0, 255);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
-        cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
+    cv::gpu::GpuMat dst = createMat(cv::Size(size.width + 2 * border, size.height + 2 * border), type, useRoi);
+    cv::gpu::copyMakeBorder(loadMat(src, useRoi), dst, border, border, border, border, borderType, val);
 
-        cv::Mat dst_gold;
-        cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
+    cv::Mat dst_gold;
+    cv::copyMakeBorder(src, dst_gold, border, border, border, border, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index d943ec7e7..695ec9758 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -70,44 +70,36 @@ PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Merge, Accuracy)
 {
-    try
+    std::vector<cv::Mat> src;
+    src.reserve(channels);
+    for (int i = 0; i < channels; ++i)
+        src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
+
+    std::vector<cv::gpu::GpuMat> d_src;
+    for (int i = 0; i < channels; ++i)
+        d_src.push_back(loadMat(src[i], useRoi));
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        std::vector<cv::Mat> src;
-        src.reserve(channels);
-        for (int i = 0; i < channels; ++i)
-            src.push_back(cv::Mat(size, depth, cv::Scalar::all(i)));
-
-        std::vector<cv::gpu::GpuMat> d_src;
-        for (int i = 0; i < channels; ++i)
-            d_src.push_back(loadMat(src[i], useRoi));
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::merge(d_src, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+        try
         {
             cv::gpu::GpuMat dst;
             cv::gpu::merge(d_src, dst);
-
-            cv::Mat dst_gold;
-            cv::merge(src, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst;
+        cv::gpu::merge(d_src, dst);
+
+        cv::Mat dst_gold;
+        cv::merge(src, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -147,42 +139,34 @@ PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
 
 TEST_P(Split, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                std::vector<cv::gpu::GpuMat> dst;
-                cv::gpu::split(loadMat(src), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             std::vector<cv::gpu::GpuMat> dst;
-            cv::gpu::split(loadMat(src, useRoi), dst);
-
-            std::vector<cv::Mat> dst_gold;
-            cv::split(src, dst_gold);
-
-            ASSERT_EQ(dst_gold.size(), dst.size());
-
-            for (size_t i = 0; i < dst_gold.size(); ++i)
-            {
-                EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
-            }
+            cv::gpu::split(loadMat(src), dst);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        std::vector<cv::gpu::GpuMat> dst;
+        cv::gpu::split(loadMat(src, useRoi), dst);
+
+        std::vector<cv::Mat> dst_gold;
+        cv::split(src, dst_gold);
+
+        ASSERT_EQ(dst_gold.size(), dst.size());
+
+        for (size_t i = 0; i < dst_gold.size(); ++i)
+        {
+            EXPECT_MAT_NEAR(dst_gold[i], dst[i], 0.0);
+        }
     }
 }
 
@@ -224,39 +208,31 @@ PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, Ma
 
 TEST_P(Add_Array, Accuracy)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::add(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -293,40 +269,32 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Add_Array_Mask, Accuracy)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0, 2);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::add(mat1, mat2, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::add(mat1, mat2, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -359,78 +327,62 @@ PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, M
 
 TEST_P(Add_Scalar, WithOutMask)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::add(mat, val, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Add_Scalar, WithMask)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::add(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::add(mat, val, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::add(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::add(mat, val, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -471,39 +423,31 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Subtract_Array, Accuracy)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::subtract(mat1, mat2, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -540,40 +484,32 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<Ma
 
 TEST_P(Subtract_Array_Mask, Accuracy)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat1), loadMat(mat2), dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
-            cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, dtype, cv::Scalar::all(0));
+        cv::subtract(mat1, mat2, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -606,78 +542,62 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Subtract_Scalar, WithOutMask)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, cv::gpu::GpuMat(), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::subtract(mat, val, dst_gold, cv::noArray(), depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Subtract_Scalar, WithMask)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::subtract(loadMat(mat), val, dst, cv::gpu::GpuMat(), depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            dst.setTo(cv::Scalar::all(0));
-            cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
-
-            cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
-            cv::subtract(mat, val, dst_gold, mask, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        dst.setTo(cv::Scalar::all(0));
+        cv::gpu::subtract(loadMat(mat, useRoi), val, dst, loadMat(mask, useRoi), depth.second);
+
+        cv::Mat dst_gold(size, depth.second, cv::Scalar::all(0));
+        cv::subtract(mat, val, dst_gold, mask, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -718,76 +638,60 @@ PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
 
 TEST_P(Multiply_Array, WithOutScale)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat1, mat2, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 
 TEST_P(Multiply_Array, WithScale)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype);
+    double scale = randomDouble(0.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype);
-        double scale = randomDouble(0.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat1, mat2, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 2.0);
     }
 }
 
@@ -819,92 +723,76 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
 {
-    try
+    cv::Mat mat1 = randomMat(size, CV_8UC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1);
+
+    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+    cv::Mat h_dst(dst);
+
+    for (int y = 0; y < h_dst.rows; ++y)
     {
-        cv::Mat mat1 = randomMat(size, CV_8UC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1);
+        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-        cv::Mat h_dst(dst);
-
-        for (int y = 0; y < h_dst.rows; ++y)
+        for (int x = 0; x < h_dst.cols; ++x)
         {
-            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+            cv::Vec4b val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4b actual = dst_row[x];
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4b val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4b actual = dst_row[x];
+            cv::Vec4b gold;
 
-                cv::Vec4b gold;
+            gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
+            gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
+            gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
+            gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
 
-                gold[0] = cv::saturate_cast<uchar>(val1[0] * val2);
-                gold[1] = cv::saturate_cast<uchar>(val1[1] * val2);
-                gold[2] = cv::saturate_cast<uchar>(val1[2] * val2);
-                gold[3] = cv::saturate_cast<uchar>(val1[3] * val2);
-
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
 {
-    try
+    cv::Mat mat1 = randomMat(size, CV_16SC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1);
+
+    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+    cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+    cv::Mat h_dst(dst);
+
+    for (int y = 0; y < h_dst.rows; ++y)
     {
-        cv::Mat mat1 = randomMat(size, CV_16SC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1);
+        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-        cv::gpu::multiply(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-        cv::Mat h_dst(dst);
-
-        for (int y = 0; y < h_dst.rows; ++y)
+        for (int x = 0; x < h_dst.cols; ++x)
         {
-            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+            cv::Vec4s val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4s actual = dst_row[x];
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4s val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4s actual = dst_row[x];
+            cv::Vec4s gold;
 
-                cv::Vec4s gold;
+            gold[0] = cv::saturate_cast<short>(val1[0] * val2);
+            gold[1] = cv::saturate_cast<short>(val1[1] * val2);
+            gold[2] = cv::saturate_cast<short>(val1[2] * val2);
+            gold[3] = cv::saturate_cast<short>(val1[3] * val2);
 
-                gold[0] = cv::saturate_cast<short>(val1[0] * val2);
-                gold[1] = cv::saturate_cast<short>(val1[1] * val2);
-                gold[2] = cv::saturate_cast<short>(val1[2] * val2);
-                gold[3] = cv::saturate_cast<short>(val1[3] * val2);
-
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Multiply_Array_Special, testing::Combine(
@@ -935,77 +823,61 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
 
 TEST_P(Multiply_Scalar, WithOutScale)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat), val, dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat, val, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat, val, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
 
 TEST_P(Multiply_Scalar, WithScale)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(0, 255);
+    double scale = randomDouble(0.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(0, 255);
-        double scale = randomDouble(0.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::multiply(loadMat(mat), val, dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::multiply(mat, val, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::multiply(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::multiply(mat, val, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 1.0);
     }
 }
 
@@ -1046,77 +918,61 @@ PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth,
 
 TEST_P(Divide_Array, WithOutScale)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat1, mat2, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat1, mat2, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 1.0);
     }
 }
 
 
 TEST_P(Divide_Array, WithScale)
 {
-    try
+    cv::Mat mat1 = randomMat(size, stype);
+    cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
+    double scale = randomDouble(0.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat1 = randomMat(size, stype);
-        cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
-        double scale = randomDouble(0.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat1), loadMat(mat2), dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
-            cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat1, mat2, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dtype, useRoi);
+        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat1, mat2, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 1.0);
     }
 }
 
@@ -1148,92 +1004,76 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
 {
-    try
+    cv::Mat mat1 = randomMat(size, CV_8UC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+
+    cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
+    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+    cv::Mat h_dst(dst);
+
+    for (int y = 0; y < h_dst.rows; ++y)
     {
-        cv::Mat mat1 = randomMat(size, CV_8UC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+        const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_8UC4, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-        cv::Mat h_dst(dst);
-
-        for (int y = 0; y < h_dst.rows; ++y)
+        for (int x = 0; x < h_dst.cols; ++x)
         {
-            const cv::Vec4b* mat1_row = mat1.ptr<cv::Vec4b>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4b* dst_row = h_dst.ptr<cv::Vec4b>(y);
+            cv::Vec4b val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4b actual = dst_row[x];
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4b val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4b actual = dst_row[x];
+            cv::Vec4b gold;
 
-                cv::Vec4b gold;
+            gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
+            gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
+            gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
+            gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
 
-                gold[0] = cv::saturate_cast<uchar>(val1[0] / val2);
-                gold[1] = cv::saturate_cast<uchar>(val1[1] / val2);
-                gold[2] = cv::saturate_cast<uchar>(val1[2] / val2);
-                gold[3] = cv::saturate_cast<uchar>(val1[3] / val2);
-
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
 {
-    try
+    cv::Mat mat1 = randomMat(size, CV_16SC4);
+    cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+
+    cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
+    cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
+
+    cv::Mat h_dst(dst);
+
+    for (int y = 0; y < h_dst.rows; ++y)
     {
-        cv::Mat mat1 = randomMat(size, CV_16SC4);
-        cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
+        const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
+        const float* mat2_row = mat2.ptr<float>(y);
+        const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_16SC4, useRoi);
-        cv::gpu::divide(loadMat(mat1, useRoi), loadMat(mat2, useRoi), dst);
-
-        cv::Mat h_dst(dst);
-
-        for (int y = 0; y < h_dst.rows; ++y)
+        for (int x = 0; x < h_dst.cols; ++x)
         {
-            const cv::Vec4s* mat1_row = mat1.ptr<cv::Vec4s>(y);
-            const float* mat2_row = mat2.ptr<float>(y);
-            const cv::Vec4s* dst_row = h_dst.ptr<cv::Vec4s>(y);
+            cv::Vec4s val1 = mat1_row[x];
+            float val2 = mat2_row[x];
+            cv::Vec4s actual = dst_row[x];
 
-            for (int x = 0; x < h_dst.cols; ++x)
-            {
-                cv::Vec4s val1 = mat1_row[x];
-                float val2 = mat2_row[x];
-                cv::Vec4s actual = dst_row[x];
+            cv::Vec4s gold;
 
-                cv::Vec4s gold;
+            gold[0] = cv::saturate_cast<short>(val1[0] / val2);
+            gold[1] = cv::saturate_cast<short>(val1[1] / val2);
+            gold[2] = cv::saturate_cast<short>(val1[2] / val2);
+            gold[3] = cv::saturate_cast<short>(val1[3] / val2);
 
-                gold[0] = cv::saturate_cast<short>(val1[0] / val2);
-                gold[1] = cv::saturate_cast<short>(val1[1] / val2);
-                gold[2] = cv::saturate_cast<short>(val1[2] / val2);
-                gold[3] = cv::saturate_cast<short>(val1[3] / val2);
-
-                ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-                ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
-            }
+            ASSERT_LE(std::abs(gold[0] - actual[0]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
+            ASSERT_LE(std::abs(gold[1] - actual[1]), 1.0);
         }
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Divide_Array_Special, testing::Combine(
@@ -1264,76 +1104,60 @@ PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth
 
 TEST_P(Divide_Scalar, WithOutScale)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(1.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(1.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat), val, dst, 1, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat, val, dst_gold, 1, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(loadMat(mat, useRoi), val, dst, 1, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat, val, dst_gold, 1, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
 TEST_P(Divide_Scalar, WithScale)
 {
-    try
+    cv::Mat mat = randomMat(size, depth.first);
+    cv::Scalar val = randomScalar(1.0, 255.0);
+    double scale = randomDouble(0.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat mat = randomMat(size, depth.first);
-        cv::Scalar val = randomScalar(1.0, 255.0);
-        double scale = randomDouble(0.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(loadMat(mat), val, dst, scale, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(mat, val, dst_gold, scale, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(loadMat(mat, useRoi), val, dst, scale, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(mat, val, dst_gold, scale, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-2 : 0.0);
     }
 }
 
@@ -1366,38 +1190,30 @@ PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatD
 
 TEST_P(Divide_Scalar_Inv, Accuracy)
 {
-    try
+    double scale = randomDouble(0.0, 255.0);
+    cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
+
+    if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        double scale = randomDouble(0.0, 255.0);
-        cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
-
-        if ((depth.first == CV_64F || depth.second == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::divide(scale, loadMat(mat), dst, depth.second);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
-            cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
-
-            cv::Mat dst_gold;
-            cv::divide(scale, mat, dst_gold, depth.second);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth.second, useRoi);
+        cv::gpu::divide(scale, loadMat(mat, useRoi), dst, depth.second);
+
+        cv::Mat dst_gold;
+        cv::divide(scale, mat, dst_gold, depth.second);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth.first >= CV_32F || depth.second >= CV_32F ? 1e-4 : 0.0);
     }
 }
 
@@ -1430,75 +1246,59 @@ PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(AbsDiff, Array)
 {
-    try
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::absdiff(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold;
-            cv::absdiff(src1, src2, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::absdiff(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold;
+        cv::absdiff(src1, src2, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(AbsDiff, Scalar)
 {
-    try
+    cv::Mat src = randomMat(size, depth);
+    cv::Scalar val = randomScalar(0.0, 255.0);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth);
-        cv::Scalar val = randomScalar(0.0, 255.0);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::absdiff(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::absdiff(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold;
-            cv::absdiff(src, val, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::absdiff(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold;
+        cv::absdiff(src, val, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth <= CV_32F ? 1.0 : 1e-5);
     }
 }
 
@@ -1531,22 +1331,14 @@ PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Abs, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::abs(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::abs(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold = cv::abs(src);
+    cv::Mat dst_gold = cv::abs(src);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Abs, testing::Combine(
@@ -1578,23 +1370,15 @@ PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqr, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
+    cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::sqr(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::sqr(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::multiply(src, src, dst_gold);
+    cv::Mat dst_gold;
+    cv::multiply(src, src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
@@ -1653,23 +1437,15 @@ PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Sqrt, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::sqrt(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::sqrt(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        sqrtGold(src, dst_gold);
+    cv::Mat dst_gold;
+    sqrtGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
@@ -1728,23 +1504,15 @@ PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Log, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 1.0, 255.0);
+    cv::Mat src = randomMat(size, depth, 1.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::log(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::log(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        logGold(src, dst_gold);
+    cv::Mat dst_gold;
+    logGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-6);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
@@ -1813,23 +1581,15 @@ PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Exp, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
 
-        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-        cv::gpu::exp(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+    cv::gpu::exp(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        expGold(src, dst_gold);
+    cv::Mat dst_gold;
+    expGold(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 1.0 : 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Exp, testing::Combine(
@@ -1869,38 +1629,30 @@ PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode,
 
 TEST_P(Compare_Array, Accuracy)
 {
-    try
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::compare(loadMat(src1), loadMat(src2), dst, cmp_code);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
-            cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
-
-            cv::Mat dst_gold;
-            cv::compare(src1, src2, dst_gold, cmp_code);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, CV_8UC1, useRoi);
+        cv::gpu::compare(loadMat(src1, useRoi), loadMat(src2, useRoi), dst, cmp_code);
+
+        cv::Mat dst_gold;
+        cv::compare(src1, src2, dst_gold, cmp_code);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -1979,47 +1731,39 @@ PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode,
 
 TEST_P(Compare_Scalar, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar sc = randomScalar(0.0, 255.0);
+
+    if (src.depth() < CV_32F)
     {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar sc = randomScalar(0.0, 255.0);
+        sc.val[0] = cvRound(sc.val[0]);
+        sc.val[1] = cvRound(sc.val[1]);
+        sc.val[2] = cvRound(sc.val[2]);
+        sc.val[3] = cvRound(sc.val[3]);
+    }
 
-        if (src.depth() < CV_32F)
+    if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
-            sc.val[0] = cvRound(sc.val[0]);
-            sc.val[1] = cvRound(sc.val[1]);
-            sc.val[2] = cvRound(sc.val[2]);
-            sc.val[3] = cvRound(sc.val[3]);
+            cv::gpu::GpuMat dst;
+            cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
         }
-
-        if (src.depth() == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        catch (const cv::Exception& e)
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::compare(loadMat(src), sc, dst, cmp_code);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
-
-            cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
-
-            cv::Mat dst_gold;
-            compareScalarGold(src, sc, dst_gold, cmp_code);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(CV_8U, src.channels()), useRoi);
+
+        cv::gpu::compare(loadMat(src, useRoi), sc, dst, cmp_code);
+
+        cv::Mat dst_gold;
+        compareScalarGold(src, sc, dst_gold, cmp_code);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2057,74 +1801,42 @@ PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(Bitwise_Array, Not)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_not(loadMat(src1), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_not(loadMat(src1), dst);
 
-        cv::Mat dst_gold = ~src1;
+    cv::Mat dst_gold = ~src1;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, Or)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 | src2;
+    cv::Mat dst_gold = src1 | src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, And)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 & src2;
+    cv::Mat dst_gold = src1 & src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Array, Xor)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
 
-        cv::Mat dst_gold = src1 ^ src2;
+    cv::Mat dst_gold = src1 ^ src2;
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Array, testing::Combine(
@@ -2162,59 +1874,35 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channel
 
 TEST_P(Bitwise_Scalar, Or)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_or(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_or(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_or(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_or(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Scalar, And)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_and(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_and(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_and(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_and(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(Bitwise_Scalar, Xor)
 {
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::bitwise_xor(loadMat(src), val, dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::bitwise_xor(loadMat(src), val, dst);
 
-        cv::Mat dst_gold;
-        cv::bitwise_xor(src, val, dst_gold);
+    cv::Mat dst_gold;
+    cv::bitwise_xor(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
@@ -2276,25 +1964,17 @@ PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(RShift, Accuracy)
 {
-    try
-    {
-        int type = CV_MAKE_TYPE(depth, channels);
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    int type = CV_MAKE_TYPE(depth, channels);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::rshift(loadMat(src, useRoi), val, dst);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::rshift(loadMat(src, useRoi), val, dst);
 
-        cv::Mat dst_gold;
-        rhiftGold(src, val, dst_gold);
+    cv::Mat dst_gold;
+    rhiftGold(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine(
@@ -2361,25 +2041,17 @@ PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
 
 TEST_P(LShift, Accuracy)
 {
-    try
-    {
-        int type = CV_MAKE_TYPE(depth, channels);
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar_<int> val = randomScalar(0.0, 8.0);
+    int type = CV_MAKE_TYPE(depth, channels);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar_<int> val = randomScalar(0.0, 8.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::lshift(loadMat(src, useRoi), val, dst);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::lshift(loadMat(src, useRoi), val, dst);
 
-        cv::Mat dst_gold;
-        lhiftGold(src, val, dst_gold);
+    cv::Mat dst_gold;
+    lhiftGold(src, val, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LShift, testing::Combine(
@@ -2412,73 +2084,57 @@ PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Min, Array)
 {
-    try
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::min(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::min(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold = cv::min(src1, src2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::min(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold = cv::min(src1, src2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(Min, Scalar)
 {
-    try
+    cv::Mat src = randomMat(size, depth);
+    double val = randomDouble(0.0, 255.0);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth);
-        double val = randomDouble(0.0, 255.0);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::min(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::min(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::min(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold = cv::min(src, val);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::min(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold = cv::min(src, val);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2511,73 +2167,57 @@ PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Max, Array)
 {
-    try
+    cv::Mat src1 = randomMat(size, depth);
+    cv::Mat src2 = randomMat(size, depth);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src1 = randomMat(size, depth);
-        cv::Mat src2 = randomMat(size, depth);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::max(loadMat(src1), loadMat(src2), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::max(loadMat(src1), loadMat(src2), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
-
-            cv::Mat dst_gold = cv::max(src1, src2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::max(loadMat(src1, useRoi), loadMat(src2, useRoi), dst);
+
+        cv::Mat dst_gold = cv::max(src1, src2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(Max, Scalar)
 {
-    try
+    cv::Mat src = randomMat(size, depth);
+    double val = randomDouble(0.0, 255.0);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth);
-        double val = randomDouble(0.0, 255.0);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::max(loadMat(src), val, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::max(loadMat(src), val, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::max(loadMat(src, useRoi), val, dst);
-
-            cv::Mat dst_gold = cv::max(src, val);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::max(loadMat(src, useRoi), val, dst);
+
+        cv::Mat dst_gold = cv::max(src, val);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2610,41 +2250,33 @@ PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(Pow, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, depth, 0.0, 10.0);
+    double power = randomDouble(2.0, 4.0);
+
+    if (src.depth() < CV_32F)
+        power = static_cast<int>(power);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth, 0.0, 10.0);
-        double power = randomDouble(2.0, 4.0);
-
-        if (src.depth() < CV_32F)
-            power = static_cast<int>(power);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::pow(loadMat(src), power, dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::pow(loadMat(src), power, dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
-            cv::gpu::pow(loadMat(src, useRoi), power, dst);
-
-            cv::Mat dst_gold;
-            cv::pow(src, power, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, depth, useRoi);
+        cv::gpu::pow(loadMat(src, useRoi), power, dst);
+
+        cv::Mat dst_gold;
+        cv::pow(src, power, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth < CV_32F ? 0.0 : 1e-1);
     }
 }
 
@@ -2681,41 +2313,33 @@ PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth,
 
 TEST_P(AddWeighted, Accuracy)
 {
-    try
+    cv::Mat src1 = randomMat(size, depth1);
+    cv::Mat src2 = randomMat(size, depth2);
+    double alpha = randomDouble(-10.0, 10.0);
+    double beta = randomDouble(-10.0, 10.0);
+    double gamma = randomDouble(-10.0, 10.0);
+
+    if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src1 = randomMat(size, depth1);
-        cv::Mat src2 = randomMat(size, depth2);
-        double alpha = randomDouble(-10.0, 10.0);
-        double beta = randomDouble(-10.0, 10.0);
-        double gamma = randomDouble(-10.0, 10.0);
-
-        if ((depth1 == CV_64F || depth2 == CV_64F || dst_depth == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::addWeighted(loadMat(src1), alpha, loadMat(src2), beta, gamma, dst, dst_depth);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
-            cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
-
-            cv::Mat dst_gold;
-            cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, dst_depth, useRoi);
+        cv::gpu::addWeighted(loadMat(src1, useRoi), alpha, loadMat(src2, useRoi), beta, gamma, dst, dst_depth);
+
+        cv::Mat dst_gold;
+        cv::addWeighted(src1, alpha, src2, beta, gamma, dst_gold, dst_depth);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 1.0 : 1e-3);
     }
 }
 
@@ -2730,8 +2354,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // GEMM
 
-#ifdef HAVE_CUBLAS
-
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
 #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
 
@@ -2757,54 +2379,58 @@ PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
 
 TEST_P(GEMM, Accuracy)
 {
+    cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
+    cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
+    cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
+    double alpha = randomDouble(-10.0, 10.0);
+    double beta = randomDouble(-10.0, 10.0);
+
+#ifndef HAVE_CUBLAS
     try
     {
-        cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
-        cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
-        cv::Mat src3 = randomMat(size, type, -10.0, 10.0);
-        double alpha = randomDouble(-10.0, 10.0);
-        double beta = randomDouble(-10.0, 10.0);
-
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else if (type == CV_64FC2 && flags != 0)
-        {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-            cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
-
-            cv::Mat dst_gold;
-            cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
-        }
+        cv::gpu::GpuMat dst;
+        cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
     }
-    catch (...)
+    catch (const cv::Exception& e)
     {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_EQ(CV_StsNotImplemented, e.code);
     }
+#else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
+        {
+            cv::gpu::GpuMat dst;
+            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
+        }
+    }
+    else if (type == CV_64FC2 && flags != 0)
+    {
+        try
+        {
+            cv::gpu::GpuMat dst;
+            cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::gemm(loadMat(src1, useRoi), loadMat(src2, useRoi), alpha, loadMat(src3, useRoi), beta, dst, flags);
+
+        cv::Mat dst_gold;
+        cv::gemm(src1, src2, alpha, src3, beta, dst_gold, flags);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
+    }
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
@@ -2814,8 +2440,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
     ALL_GEMM_FLAGS,
     WHOLE_SUBMAT));
 
-#endif // HAVE_CUBLAS
-
 ////////////////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -2839,37 +2463,29 @@ PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Transpose, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, type);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, type);
-
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::transpose(loadMat(src), dst);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::transpose(loadMat(src), dst);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
-            cv::gpu::transpose(loadMat(src, useRoi), dst);
-
-            cv::Mat dst_gold;
-            cv::transpose(src, dst_gold);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(cv::Size(size.height, size.width), type, useRoi);
+        cv::gpu::transpose(loadMat(src, useRoi), dst);
+
+        cv::Mat dst_gold;
+        cv::transpose(src, dst_gold);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -2914,23 +2530,15 @@ PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
 
 TEST_P(Flip, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::flip(loadMat(src, useRoi), dst, flip_code);
 
-        cv::Mat dst_gold;
-        cv::flip(src, dst_gold, flip_code);
+    cv::Mat dst_gold;
+    cv::flip(src, dst_gold, flip_code);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Flip, testing::Combine(
@@ -2974,46 +2582,30 @@ PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(LUT, OneChannel)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
-        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()));
+    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-        cv::Mat dst_gold;
-        cv::LUT(src, lut, dst_gold);
+    cv::Mat dst_gold;
+    cv::LUT(src, lut, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 TEST_P(LUT, MultiChannel)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
+    cv::Mat src = randomMat(size, type);
+    cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
 
-        cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
-        cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_MAKE_TYPE(lut.depth(), src.channels()), useRoi);
+    cv::gpu::LUT(loadMat(src, useRoi), lut, dst);
 
-        cv::Mat dst_gold;
-        cv::LUT(src, lut, dst_gold);
+    cv::Mat dst_gold;
+    cv::LUT(src, lut, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, LUT, testing::Combine(
@@ -3043,94 +2635,62 @@ PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Magnitude, NPP)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC2);
+    cv::Mat src = randomMat(size, CV_32FC2);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitude(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitude(loadMat(src, useRoi), dst);
 
-        cv::Mat arr[2];
-        cv::split(src, arr);
-        cv::Mat dst_gold;
-        cv::magnitude(arr[0], arr[1], dst_gold);
+    cv::Mat arr[2];
+    cv::split(src, arr);
+    cv::Mat dst_gold;
+    cv::magnitude(arr[0], arr[1], dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
 TEST_P(Magnitude, Sqr_NPP)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC2);
+    cv::Mat src = randomMat(size, CV_32FC2);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitudeSqr(loadMat(src, useRoi), dst);
 
-        cv::Mat arr[2];
-        cv::split(src, arr);
-        cv::Mat dst_gold;
-        cv::magnitude(arr[0], arr[1], dst_gold);
-        cv::multiply(dst_gold, dst_gold, dst_gold);
+    cv::Mat arr[2];
+    cv::split(src, arr);
+    cv::Mat dst_gold;
+    cv::magnitude(arr[0], arr[1], dst_gold);
+    cv::multiply(dst_gold, dst_gold, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
 }
 
 TEST_P(Magnitude, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitude(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::magnitude(x, y, dst_gold);
+    cv::Mat dst_gold;
+    cv::magnitude(x, y, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
 TEST_P(Magnitude, Sqr_Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::magnitudeSqr(loadMat(x, useRoi), loadMat(y, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::magnitude(x, y, dst_gold);
-        cv::multiply(dst_gold, dst_gold, dst_gold);
+    cv::Mat dst_gold;
+    cv::magnitude(x, y, dst_gold);
+    cv::multiply(dst_gold, dst_gold, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine(
@@ -3163,24 +2723,16 @@ PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
 
 TEST_P(Phase, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
+    cv::gpu::GpuMat dst = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::phase(loadMat(x, useRoi), loadMat(y, useRoi), dst, angleInDegrees);
 
-        cv::Mat dst_gold;
-        cv::phase(x, y, dst_gold, angleInDegrees);
+    cv::Mat dst_gold;
+    cv::phase(x, y, dst_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, angleInDegrees ? 1e-2 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Phase, testing::Combine(
@@ -3212,27 +2764,19 @@ PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(CartToPolar, Accuracy)
 {
-    try
-    {
-        cv::Mat x = randomMat(size, CV_32FC1);
-        cv::Mat y = randomMat(size, CV_32FC1);
+    cv::Mat x = randomMat(size, CV_32FC1);
+    cv::Mat y = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
+    cv::gpu::GpuMat mag = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::GpuMat angle = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::cartToPolar(loadMat(x, useRoi), loadMat(y, useRoi), mag, angle, angleInDegrees);
 
-        cv::Mat mag_gold;
-        cv::Mat angle_gold;
-        cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
+    cv::Mat mag_gold;
+    cv::Mat angle_gold;
+    cv::cartToPolar(x, y, mag_gold, angle_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
-        EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(mag_gold, mag, 1e-4);
+    EXPECT_MAT_NEAR(angle_gold, angle, angleInDegrees ? 1e-2 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, CartToPolar, testing::Combine(
@@ -3264,27 +2808,19 @@ PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
 
 TEST_P(PolarToCart, Accuracy)
 {
-    try
-    {
-        cv::Mat magnitude = randomMat(size, CV_32FC1);
-        cv::Mat angle = randomMat(size, CV_32FC1);
+    cv::Mat magnitude = randomMat(size, CV_32FC1);
+    cv::Mat angle = randomMat(size, CV_32FC1);
 
-        cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
-        cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
+    cv::gpu::GpuMat x = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::GpuMat y = createMat(size, CV_32FC1, useRoi);
+    cv::gpu::polarToCart(loadMat(magnitude, useRoi), loadMat(angle, useRoi), x, y, angleInDegrees);
 
-        cv::Mat x_gold;
-        cv::Mat y_gold;
-        cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
+    cv::Mat x_gold;
+    cv::Mat y_gold;
+    cv::polarToCart(magnitude, angle, x_gold, y_gold, angleInDegrees);
 
-        EXPECT_MAT_NEAR(x_gold, x, 1e-4);
-        EXPECT_MAT_NEAR(y_gold, y, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(x_gold, x, 1e-4);
+    EXPECT_MAT_NEAR(y_gold, y, 1e-4);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, PolarToCart, testing::Combine(
@@ -3314,41 +2850,33 @@ PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(MeanStdDev, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
-        {
-            try
-            {
-                cv::Scalar mean;
-                cv::Scalar stddev;
-                cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
-        }
-        else
+    if (!supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_13))
+    {
+        try
         {
             cv::Scalar mean;
             cv::Scalar stddev;
             cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
-
-            cv::Scalar mean_gold;
-            cv::Scalar stddev_gold;
-            cv::meanStdDev(src, mean_gold, stddev_gold);
-
-            EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
-            EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Scalar mean;
+        cv::Scalar stddev;
+        cv::gpu::meanStdDev(loadMat(src, useRoi), mean, stddev);
+
+        cv::Scalar mean_gold;
+        cv::Scalar stddev_gold;
+        cv::meanStdDev(src, mean_gold, stddev_gold);
+
+        EXPECT_SCALAR_NEAR(mean_gold, mean, 1e-5);
+        EXPECT_SCALAR_NEAR(stddev_gold, stddev, 1e-5);
     }
 }
 
@@ -3382,21 +2910,13 @@ PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
 
 TEST_P(Norm, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
+    double val = cv::gpu::norm(loadMat(src, useRoi), normCode);
 
-        double val_gold = cv::norm(src, normCode);
+    double val_gold = cv::norm(src, normCode);
 
-        EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_NEAR(val_gold, val, depth < CV_32F ? 0.0 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Norm, testing::Combine(
@@ -3434,22 +2954,14 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
 
 TEST_P(NormDiff, Accuracy)
 {
-    try
-    {
-        cv::Mat src1 = randomMat(size, CV_8UC1);
-        cv::Mat src2 = randomMat(size, CV_8UC1);
+    cv::Mat src1 = randomMat(size, CV_8UC1);
+    cv::Mat src2 = randomMat(size, CV_8UC1);
 
-        double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
+    double val = cv::gpu::norm(loadMat(src1, useRoi), loadMat(src2, useRoi), normCode);
 
-        double val_gold = cv::norm(src1, src2, normCode);
+    double val_gold = cv::norm(src1, src2, normCode);
 
-        EXPECT_NEAR(val_gold, val, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_NEAR(val_gold, val, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine(
@@ -3562,53 +3074,29 @@ PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Sum, Simple)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = cv::sum(src);
+    cv::Scalar val_gold = cv::sum(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 TEST_P(Sum, Abs)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = absSumGold(src);
+    cv::Scalar val_gold = absSumGold(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 TEST_P(Sum, Sqr)
 {
-    try
-    {
-        cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
+    cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
 
-        cv::Scalar val_gold = sqrSumGold(src);
+    cv::Scalar val_gold = sqrSumGold(src);
 
-        EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Sum, testing::Combine(
@@ -3640,115 +3128,91 @@ PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMax, WithoutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            cv::gpu::minMax(loadMat(src), &minVal, &maxVal);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal);
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
 TEST_P(MinMax, WithMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat src = randomMat(size, depth);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            cv::gpu::minMax(loadMat(src), &minVal, &maxVal, loadMat(mask));
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, &maxVal, loadMat(mask, useRoi));
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0, mask);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
 TEST_P(MinMax, NullPtr)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::gpu::minMax(loadMat(src), &minVal, 0);
-                cv::gpu::minMax(loadMat(src), 0, &maxVal);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
-            cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
-            cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
-
-            double minVal_gold, maxVal_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+            cv::gpu::minMax(loadMat(src), &minVal, 0);
+            cv::gpu::minMax(loadMat(src), 0, &maxVal);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::gpu::minMax(loadMat(src, useRoi), &minVal, 0);
+        cv::gpu::minMax(loadMat(src, useRoi), 0, &maxVal);
+
+        double minVal_gold, maxVal_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, 0, 0);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
     }
 }
 
@@ -3805,114 +3269,82 @@ PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(MinMaxLoc, WithoutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc);
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
 TEST_P(MinMaxLoc, WithMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+    cv::Mat src = randomMat(size, depth);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
-            cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+            cv::gpu::minMaxLoc(loadMat(src), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask));
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, &maxVal, &minLoc, &maxLoc, loadMat(mask, useRoi));
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold, mask);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
 TEST_P(MinMaxLoc, NullPtr)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, depth);
+    cv::Mat src = randomMat(size, depth);
 
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                double minVal, maxVal;
-                cv::Point minLoc, maxLoc;
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
-                cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             double minVal, maxVal;
             cv::Point minLoc, maxLoc;
@@ -3920,22 +3352,30 @@ TEST_P(MinMaxLoc, NullPtr)
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
             cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
-
-            double minVal_gold, maxVal_gold;
-            cv::Point minLoc_gold, maxLoc_gold;
-            minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
-
-            EXPECT_DOUBLE_EQ(minVal_gold, minVal);
-            EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
-
-            expectEqual(src, minLoc_gold, minLoc);
-            expectEqual(src, maxLoc_gold, maxLoc);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        double minVal, maxVal;
+        cv::Point minLoc, maxLoc;
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), &minVal, 0, 0, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, &maxVal, 0, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, &minLoc, 0);
+        cv::gpu::minMaxLoc(loadMat(src, useRoi), 0, 0, 0, &maxLoc);
+
+        double minVal_gold, maxVal_gold;
+        cv::Point minLoc_gold, maxLoc_gold;
+        minMaxLocGold(src, &minVal_gold, &maxVal_gold, &minLoc_gold, &maxLoc_gold);
+
+        EXPECT_DOUBLE_EQ(minVal_gold, minVal);
+        EXPECT_DOUBLE_EQ(maxVal_gold, maxVal);
+
+        expectEqual(src, minLoc_gold, minLoc);
+        expectEqual(src, maxLoc_gold, maxLoc);
     }
 }
 
@@ -3969,36 +3409,28 @@ PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
 
 TEST_P(CountNonZero, Accuracy)
 {
-    try
+    cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
+    cv::Mat src;
+    srcBase.convertTo(src, depth);
+
+    if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
-        cv::Mat src;
-        srcBase.convertTo(src, depth);
-
-        if (depth == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::countNonZero(loadMat(src));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::countNonZero(loadMat(src));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            int val = cv::gpu::countNonZero(loadMat(src, useRoi));
-
-            int val_gold = cv::countNonZero(src);
-
-            ASSERT_EQ(val_gold, val);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        int val = cv::gpu::countNonZero(loadMat(src, useRoi));
+
+        int val_gold = cv::countNonZero(src);
+
+        ASSERT_EQ(val_gold, val);
     }
 }
 
@@ -4054,47 +3486,31 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
 
 TEST_P(Reduce, Rows)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
-        cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols, 1), dst_type, useRoi);
+    cv::gpu::reduce(loadMat(src, useRoi), dst, 0, reduceOp, dst_depth);
 
-        cv::Mat dst_gold;
-        cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
+    cv::Mat dst_gold;
+    cv::reduce(src, dst_gold, 0, reduceOp, dst_depth);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
 }
 
 TEST_P(Reduce, Cols)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
-        cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.rows, 1), dst_type, useRoi);
+    cv::gpu::reduce(loadMat(src, useRoi), dst, 1, reduceOp, dst_depth);
 
-        cv::Mat dst_gold;
-        cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
-        dst_gold.cols = dst_gold.rows;
-        dst_gold.rows = 1;
-        dst_gold.step = dst_gold.cols * dst_gold.elemSize();
+    cv::Mat dst_gold;
+    cv::reduce(src, dst_gold, 1, reduceOp, dst_depth);
+    dst_gold.cols = dst_gold.rows;
+    dst_gold.rows = 1;
+    dst_gold.step = dst_gold.cols * dst_gold.elemSize();
 
-        EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
diff --git a/modules/gpu/test/test_denoising.cpp b/modules/gpu/test/test_denoising.cpp
index 5edf973f4..80bf3dbe2 100644
--- a/modules/gpu/test/test_denoising.cpp
+++ b/modules/gpu/test/test_denoising.cpp
@@ -71,25 +71,17 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
 
 TEST_P(BilateralFilter, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        src.convertTo(src, type);
-        cv::gpu::GpuMat dst;
+    src.convertTo(src, type);
+    cv::gpu::GpuMat dst;
 
-        cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
+    cv::gpu::bilateralFilter(loadMat(src), dst, kernel_size, sigma_color, sigma_spatial);
 
-        cv::Mat dst_gold;
-        cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
+    cv::Mat dst_gold;
+    cv::bilateralFilter(src, dst_gold, kernel_size, sigma_color, sigma_spatial);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BilateralFilter, testing::Combine(
@@ -115,41 +107,35 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BruteForceNonLocalMeans, Regression)
 {
-    try
-    {
-        using cv::gpu::GpuMat;
+    using cv::gpu::GpuMat;
 
-        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-        ASSERT_FALSE(bgr.empty());
+    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+    ASSERT_FALSE(bgr.empty());
 
-        cv::Mat gray;
-        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+    cv::Mat gray;
+    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-        GpuMat dbgr, dgray;
-        cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
-        cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
+    GpuMat dbgr, dgray;
+    cv::gpu::nonLocalMeans(GpuMat(bgr),  dbgr, 20);
+    cv::gpu::nonLocalMeans(GpuMat(gray), dgray, 20);
 
-    #if 0
-        dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-        dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#if 0
+    dumpImage("denoising/nlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+    dumpImage("denoising/nlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
 
-        cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-        cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+    cv::Mat bgr_gold  = readImage("denoising/nlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+    cv::Mat gray_gold  = readImage("denoising/nlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
-        EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1e-4);
+    EXPECT_MAT_NEAR(gray_gold, dgray, 1e-4);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
 
+
+
 ////////////////////////////////////////////////////////
 // Fast Force Non local means
 
@@ -166,41 +152,34 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastNonLocalMeans, Regression)
 {
-    try
-    {
-        using cv::gpu::GpuMat;
+    using cv::gpu::GpuMat;
 
-        cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
-        ASSERT_FALSE(bgr.empty());
+    cv::Mat bgr  = readImage("denoising/lena_noised_gaussian_sigma=20_multi_0.png", cv::IMREAD_COLOR);
+    ASSERT_FALSE(bgr.empty());
 
-        cv::Mat gray;
-        cv::cvtColor(bgr, gray, CV_BGR2GRAY);
+    cv::Mat gray;
+    cv::cvtColor(bgr, gray, CV_BGR2GRAY);
 
-        GpuMat dbgr, dgray;
-        cv::gpu::FastNonLocalMeansDenoising fnlmd;
+    GpuMat dbgr, dgray;
+    cv::gpu::FastNonLocalMeansDenoising fnlmd;
 
-        fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
-        fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
+    fnlmd.simpleMethod(GpuMat(gray),  dgray, 20);
+    fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
 
-    #if 0
-        //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-        //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
-    #endif
+#if 0
+    //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+    //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
+#endif
 
-        cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
-        cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
+    cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
+    cv::Mat gray_gold  = readImage("denoising/fnlm_denoised_lena_gray.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(bgr_gold.empty() || gray_gold.empty());
 
-        EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
-        EXPECT_MAT_NEAR(gray_gold, dgray, 1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(bgr_gold, dbgr, 1);
+    EXPECT_MAT_NEAR(gray_gold, dgray, 1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
 
+
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index a20ae68b4..c76fe9166 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -180,19 +180,31 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
 
 TEST_P(SURF, Detector)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
-
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -212,31 +224,38 @@ TEST_P(SURF, Detector)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Detector_Masked)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            surf(loadMat(image), loadMat(mask), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
-
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
-
         std::vector<cv::KeyPoint> keypoints;
         surf(loadMat(image), loadMat(mask), keypoints);
 
@@ -256,35 +275,43 @@ TEST_P(SURF, Detector_Masked)
 
         EXPECT_GT(matchedRatio, 0.95);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(SURF, Descriptor)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::gpu::SURF_GPU surf;
+    surf.hessianThreshold = hessianThreshold;
+    surf.nOctaves = nOctaves;
+    surf.nOctaveLayers = nOctaveLayers;
+    surf.extended = extended;
+    surf.upright = upright;
+    surf.keypointsRatio = 0.05f;
+
+    cv::SURF surf_gold;
+    surf_gold.hessianThreshold = hessianThreshold;
+    surf_gold.nOctaves = nOctaves;
+    surf_gold.nOctaveLayers = nOctaveLayers;
+    surf_gold.extended = extended;
+    surf_gold.upright = upright;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            surf(loadMat(image), cv::gpu::GpuMat(), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::gpu::SURF_GPU surf;
-        surf.hessianThreshold = hessianThreshold;
-        surf.nOctaves = nOctaves;
-        surf.nOctaveLayers = nOctaveLayers;
-        surf.extended = extended;
-        surf.upright = upright;
-        surf.keypointsRatio = 0.05f;
-
-        cv::SURF surf_gold;
-        surf_gold.hessianThreshold = hessianThreshold;
-        surf_gold.nOctaves = nOctaves;
-        surf_gold.nOctaveLayers = nOctaveLayers;
-        surf_gold.extended = extended;
-        surf_gold.upright = upright;
-
         std::vector<cv::KeyPoint> keypoints;
         surf_gold(image, cv::noArray(), keypoints);
 
@@ -303,11 +330,6 @@ TEST_P(SURF, Descriptor)
 
         EXPECT_GT(matchedRatio, 0.6);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
@@ -342,14 +364,26 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
 
 TEST_P(FAST, Accuracy)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::gpu::FAST_GPU fast(threshold);
+    fast.nonmaxSupression = nonmaxSupression;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::gpu::FAST_GPU fast(threshold);
-        fast.nonmaxSupression = nonmaxSupression;
-
         std::vector<cv::KeyPoint> keypoints;
         fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
 
@@ -358,11 +392,6 @@ TEST_P(FAST, Accuracy)
 
         ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
@@ -416,17 +445,30 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
 
 TEST_P(ORB, Accuracy)
 {
-    try
+    cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
+    mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
+
+    cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
+    orb.blurForDescriptor = blurForDescriptor;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector<cv::KeyPoint> keypoints;
+            cv::gpu::GpuMat descriptors;
+            orb(loadMat(image), loadMat(mask), keypoints, descriptors);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        cv::Mat mask(image.size(), CV_8UC1, cv::Scalar::all(1));
-        mask(cv::Range(0, image.rows / 2), cv::Range(0, image.cols / 2)).setTo(cv::Scalar::all(0));
-
-        cv::gpu::ORB_GPU orb(nFeatures, scaleFactor, nLevels, edgeThreshold, firstLevel, WTA_K, scoreType, patchSize);
-        orb.blurForDescriptor = blurForDescriptor;
-
         std::vector<cv::KeyPoint> keypoints;
         cv::gpu::GpuMat descriptors;
         orb(loadMat(image), loadMat(mask), keypoints, descriptors);
@@ -446,11 +488,6 @@ TEST_P(ORB, Accuracy)
 
         EXPECT_GT(matchedRatio, 0.35);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB,  testing::Combine(
@@ -533,156 +570,307 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
 
 TEST_P(BruteForceMatcher, Match_Single)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    cv::gpu::GpuMat mask;
+    if (useMask)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
-
-        cv::gpu::GpuMat mask;
-        if (useMask)
-        {
-            mask.create(query.rows, train.rows, CV_8UC1);
-            mask.setTo(cv::Scalar::all(1));
-        }
-
-        std::vector<cv::DMatch> matches;
-        matcher.match(loadMat(query), loadMat(train), matches, mask);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        for (size_t i = 0; i < matches.size(); i++)
-        {
-            cv::DMatch match = matches[i];
-            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
-                badCount++;
-        }
-
-        ASSERT_EQ(0, badCount);
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
     }
-    catch (...)
+
+    std::vector<cv::DMatch> matches;
+    matcher.match(loadMat(query), loadMat(train), matches, mask);
+
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::DMatch match = matches[i];
+        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor) || (match.imgIdx != 0))
+            badCount++;
     }
+
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, Match_Collection)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    cv::gpu::GpuMat d_train(train);
+
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount/2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
 
-        cv::gpu::GpuMat d_train(train);
+    std::vector<cv::DMatch> matches;
+    if (useMask)
+        matcher.match(cv::gpu::GpuMat(query), matches, masks);
+    else
+        matcher.match(cv::gpu::GpuMat(query), matches);
 
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++)
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        cv::DMatch match = matches[i];
+
+        if ((int)i < queryDescCount / 2)
         {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows/2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount/2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+            bool validQueryIdx = (match.queryIdx == (int)i);
+            bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
+            bool validImgIdx = (match.imgIdx == 0);
+            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                badCount++;
         }
-
-        std::vector<cv::DMatch> matches;
-        if (useMask)
-            matcher.match(cv::gpu::GpuMat(query), matches, masks);
         else
-            matcher.match(cv::gpu::GpuMat(query), matches);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
         {
-            cv::DMatch match = matches[i];
-
-            if ((int)i < queryDescCount / 2)
-            {
-                bool validQueryIdx = (match.queryIdx == (int)i);
-                bool validTrainIdx = (match.trainIdx == (int)i * countFactor + shift);
-                bool validImgIdx = (match.imgIdx == 0);
-                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                    badCount++;
-            }
-            else
-            {
-                bool validQueryIdx = (match.queryIdx == (int)i);
-                bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
-                bool validImgIdx = (match.imgIdx == 1);
-                if (!validQueryIdx || !validTrainIdx || !validImgIdx)
-                    badCount++;
-            }
+            bool validQueryIdx = (match.queryIdx == (int)i);
+            bool validTrainIdx = (match.trainIdx == ((int)i - queryDescCount / 2) * countFactor + shift);
+            bool validImgIdx = (match.imgIdx == 1);
+            if (!validQueryIdx || !validTrainIdx || !validImgIdx)
+                badCount++;
         }
+    }
 
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const int knn = 2;
+
+    cv::gpu::GpuMat mask;
+    if (useMask)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
+    }
 
-        const int knn = 2;
+    std::vector< std::vector<cv::DMatch> > matches;
+    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
 
-        cv::gpu::GpuMat mask;
-        if (useMask)
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
         {
-            mask.create(query.rows, train.rows, CV_8UC1);
-            mask.setTo(cv::Scalar::all(1));
-        }
-
-        std::vector< std::vector<cv::DMatch> > matches;
-        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        for (size_t i = 0; i < matches.size(); i++)
-        {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                        localBadCount++;
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
+                cv::DMatch match = matches[i][k];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                    localBadCount++;
             }
+            badCount += localBadCount > 0 ? 1 : 0;
         }
+    }
 
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(0, badCount);
 }
 
 TEST_P(BruteForceMatcher, KnnMatch_3_Single)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const int knn = 3;
+
+    cv::gpu::GpuMat mask;
+    if (useMask)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+        mask.create(query.rows, train.rows, CV_8UC1);
+        mask.setTo(cv::Scalar::all(1));
+    }
 
-        const int knn = 3;
+    std::vector< std::vector<cv::DMatch> > matches;
+    matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
 
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+    int badCount = 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
+                    localBadCount++;
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
+{
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const int knn = 2;
+
+    cv::gpu::GpuMat d_train(train);
+
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++ )
+    {
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
+
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    if (useMask)
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+    else
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                {
+                    if ((int)i < queryDescCount / 2)
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
+                    }
+                }
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
+{
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const int knn = 3;
+
+    cv::gpu::GpuMat d_train(train);
+
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++ )
+    {
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
+
+    std::vector< std::vector<cv::DMatch> > matches;
+
+    if (useMask)
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
+    else
+        matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
+
+    ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
+
+    int badCount = 0;
+    int shift = useMask ? 1 : 0;
+    for (size_t i = 0; i < matches.size(); i++)
+    {
+        if ((int)matches[i].size() != knn)
+            badCount++;
+        else
+        {
+            int localBadCount = 0;
+            for (int k = 0; k < knn; k++)
+            {
+                cv::DMatch match = matches[i][k];
+                {
+                    if ((int)i < queryDescCount / 2)
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
+                            localBadCount++;
+                    }
+                    else
+                    {
+                        if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
+                            localBadCount++;
+                    }
+                }
+            }
+            badCount += localBadCount > 0 ? 1 : 0;
+        }
+    }
+
+    ASSERT_EQ(0, badCount);
+}
+
+TEST_P(BruteForceMatcher, RadiusMatch_Single)
+{
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const float radius = 1.f / countFactor;
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         cv::gpu::GpuMat mask;
         if (useMask)
         {
@@ -691,258 +879,63 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single)
         }
 
         std::vector< std::vector<cv::DMatch> > matches;
-        matcher.knnMatch(loadMat(query), loadMat(train), matches, knn, mask);
+        matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
 
         ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
 
         int badCount = 0;
         for (size_t i = 0; i < matches.size(); i++)
         {
-            if ((int)matches[i].size() != knn)
+            if ((int)matches[i].size() != 1)
                 badCount++;
             else
             {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k) || (match.imgIdx != 0))
-                        localBadCount++;
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
-            }
-        }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
-}
-
-TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
-{
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
-
-        const int knn = 2;
-
-        cv::gpu::GpuMat d_train(train);
-
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-        }
-
-        std::vector< std::vector<cv::DMatch> > matches;
-
-        if (useMask)
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-        else
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
-        {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
-            {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    {
-                        if ((int)i < queryDescCount / 2)
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                                localBadCount++;
-                        }
-                        else
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                                localBadCount++;
-                        }
-                    }
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
-            }
-        }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
-}
-
-TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
-{
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
-
-        const int knn = 3;
-
-        cv::gpu::GpuMat d_train(train);
-
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++ )
-        {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
-        }
-
-        std::vector< std::vector<cv::DMatch> > matches;
-
-        if (useMask)
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn, masks);
-        else
-            matcher.knnMatch(cv::gpu::GpuMat(query), matches, knn);
-
-        ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-        int badCount = 0;
-        int shift = useMask ? 1 : 0;
-        for (size_t i = 0; i < matches.size(); i++)
-        {
-            if ((int)matches[i].size() != knn)
-                badCount++;
-            else
-            {
-                int localBadCount = 0;
-                for (int k = 0; k < knn; k++)
-                {
-                    cv::DMatch match = matches[i][k];
-                    {
-                        if ((int)i < queryDescCount / 2)
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i * countFactor + k + shift) || (match.imgIdx != 0) )
-                                localBadCount++;
-                        }
-                        else
-                        {
-                            if ((match.queryIdx != (int)i) || (match.trainIdx != ((int)i - queryDescCount / 2) * countFactor + k + shift) || (match.imgIdx != 1) )
-                                localBadCount++;
-                        }
-                    }
-                }
-                badCount += localBadCount > 0 ? 1 : 0;
-            }
-        }
-
-        ASSERT_EQ(0, badCount);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
-}
-
-TEST_P(BruteForceMatcher, RadiusMatch_Single)
-{
-    try
-    {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
-
-        const float radius = 1.f / countFactor;
-
-        if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-        {
-            try
-            {
-                std::vector< std::vector<cv::DMatch> > matches;
-                matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat mask;
-            if (useMask)
-            {
-                mask.create(query.rows, train.rows, CV_8UC1);
-                mask.setTo(cv::Scalar::all(1));
-            }
-
-            std::vector< std::vector<cv::DMatch> > matches;
-            matcher.radiusMatch(loadMat(query), loadMat(train), matches, radius, mask);
-
-            ASSERT_EQ(static_cast<size_t>(queryDescCount), matches.size());
-
-            int badCount = 0;
-            for (size_t i = 0; i < matches.size(); i++)
-            {
-                if ((int)matches[i].size() != 1)
+                cv::DMatch match = matches[i][0];
+                if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
                     badCount++;
-                else
-                {
-                    cv::DMatch match = matches[i][0];
-                    if ((match.queryIdx != (int)i) || (match.trainIdx != (int)i*countFactor) || (match.imgIdx != 0))
-                        badCount++;
-                }
             }
-
-            ASSERT_EQ(0, badCount);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        ASSERT_EQ(0, badCount);
     }
 }
 
 TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
-    try
+    cv::gpu::BFMatcher_GPU matcher(normCode);
+
+    const int n = 3;
+    const float radius = 1.f / countFactor * n;
+
+    cv::gpu::GpuMat d_train(train);
+
+    // make add() twice to test such case
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
+    matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
+
+    // prepare masks (make first nearest match illegal)
+    std::vector<cv::gpu::GpuMat> masks(2);
+    for (int mi = 0; mi < 2; mi++)
     {
-        cv::gpu::BFMatcher_GPU matcher(normCode);
+        masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
+        for (int di = 0; di < queryDescCount / 2; di++)
+            masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+    }
 
-        const int n = 3;
-        const float radius = 1.f / countFactor * n;
-
-        cv::gpu::GpuMat d_train(train);
-
-        // make add() twice to test such case
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(0, train.rows / 2)));
-        matcher.add(std::vector<cv::gpu::GpuMat>(1, d_train.rowRange(train.rows / 2, train.rows)));
-
-        // prepare masks (make first nearest match illegal)
-        std::vector<cv::gpu::GpuMat> masks(2);
-        for (int mi = 0; mi < 2; mi++)
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
         {
-            masks[mi] = cv::gpu::GpuMat(query.rows, train.rows / 2, CV_8UC1, cv::Scalar::all(1));
-            for (int di = 0; di < queryDescCount / 2; di++)
-                masks[mi].col(di * countFactor).setTo(cv::Scalar::all(0));
+            std::vector< std::vector<cv::DMatch> > matches;
+            matcher.radiusMatch(cv::gpu::GpuMat(query), matches, radius, masks);
         }
-
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
+    {
         std::vector< std::vector<cv::DMatch> > matches;
 
         if (useMask)
@@ -984,11 +977,6 @@ TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 
         ASSERT_EQ(0, badCount);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 4bdda9124..92d6fc002 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -88,23 +88,15 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
 
 TEST_P(Blur, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::blur(loadMat(src, useRoi), dst, ksize, anchor);
 
-        cv::Mat dst_gold;
-        cv::blur(src, dst_gold, ksize, anchor);
+    cv::Mat dst_gold;
+    cv::blur(src, dst_gold, ksize, anchor);
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
@@ -158,23 +150,15 @@ TEST_P(Sobel, Accuracy)
     if (dx == 0 && dy == 0)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Sobel(loadMat(src, useRoi), dst, -1, dx, dy, ksize.width, 1.0, borderType);
 
-        cv::Mat dst_gold;
-        cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
+    cv::Mat dst_gold;
+    cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
@@ -229,23 +213,15 @@ TEST_P(Scharr, Accuracy)
     if (dx + dy != 1)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Scharr(loadMat(src, useRoi), dst, -1, dx, dy, 1.0, borderType);
 
-        cv::Mat dst_gold;
-        cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
+    cv::Mat dst_gold;
+    cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(
@@ -294,39 +270,31 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
 
 TEST_P(GaussianBlur, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, type);
+    double sigma1 = randomDouble(0.1, 1.0);
+    double sigma2 = randomDouble(0.1, 1.0);
+
+    if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
     {
-        cv::Mat src = randomMat(size, type);
-        double sigma1 = randomDouble(0.1, 1.0);
-        double sigma2 = randomDouble(0.1, 1.0);
-
-        if (ksize.height > 16 && !supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat dst;
-                cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+            cv::gpu::GpuMat dst;
+            cv::gpu::GaussianBlur(loadMat(src), dst, ksize, sigma1, sigma2, borderType);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-            cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
-
-            cv::Mat dst_gold;
-            cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+        cv::gpu::GaussianBlur(loadMat(src, useRoi), dst, ksize, sigma1, sigma2, borderType);
+
+        cv::Mat dst_gold;
+        cv::GaussianBlur(src, dst_gold, ksize, sigma1, sigma2, borderType);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 4.0);
     }
 }
 
@@ -381,23 +349,15 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
 
 TEST_P(Laplacian, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::Laplacian(loadMat(src, useRoi), dst, -1, ksize.width);
 
-        cv::Mat dst_gold;
-        cv::Laplacian(src, dst_gold, -1, ksize.width);
+    cv::Mat dst_gold;
+    cv::Laplacian(src, dst_gold, -1, ksize.width);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() < CV_32F ? 0.0 : 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
@@ -436,26 +396,18 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
 
 TEST_P(Erode, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::erode(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::erode(src, dst_gold, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::erode(src, dst_gold, kernel, anchor, iterations);
 
-        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Erode, testing::Combine(
@@ -493,26 +445,18 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
 
 TEST_P(Dilate, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::dilate(loadMat(src, useRoi), dst, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::dilate(src, dst_gold, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::dilate(src, dst_gold, kernel, anchor, iterations);
 
-        cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
+    cv::Size ksize = cv::Size(kernel.cols + iterations * (kernel.cols - 1), kernel.rows + iterations * (kernel.rows - 1));
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Dilate, testing::Combine(
@@ -555,26 +499,18 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
 
 TEST_P(MorphEx, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::morphologyEx(loadMat(src, useRoi), dst, morphOp, kernel, anchor, iterations);
 
-        cv::Mat dst_gold;
-        cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
+    cv::Mat dst_gold;
+    cv::morphologyEx(src, dst_gold, morphOp, kernel, anchor, iterations);
 
-        cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
+    cv::Size border = cv::Size(kernel.cols + (iterations + 1) * kernel.cols + 2, kernel.rows + (iterations + 1) * kernel.rows + 2);
 
-        EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, border), getInnerROI(dst, border), 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, MorphEx, testing::Combine(
@@ -617,24 +553,16 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
 
 TEST_P(Filter2D, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::filter2D(loadMat(src, useRoi), dst, -1, kernel, anchor, borderType);
 
-        cv::Mat dst_gold;
-        cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
+    cv::Mat dst_gold;
+    cv::filter2D(src, dst_gold, -1, kernel, anchor, 0, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
diff --git a/modules/gpu/test/test_global_motion.cpp b/modules/gpu/test/test_global_motion.cpp
index 2b5eab894..b37d08068 100644
--- a/modules/gpu/test/test_global_motion.cpp
+++ b/modules/gpu/test/test_global_motion.cpp
@@ -53,43 +53,35 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
 
 TEST_P(CompactPoints, CanCompactizeSmallInput)
 {
-    try
-    {
-        Mat src0(1, 3, CV_32FC2);
-        src0.at<Point2f>(0,0) = Point2f(0,0);
-        src0.at<Point2f>(0,1) = Point2f(0,1);
-        src0.at<Point2f>(0,2) = Point2f(0,2);
+    Mat src0(1, 3, CV_32FC2);
+    src0.at<Point2f>(0,0) = Point2f(0,0);
+    src0.at<Point2f>(0,1) = Point2f(0,1);
+    src0.at<Point2f>(0,2) = Point2f(0,2);
 
-        Mat src1(1, 3, CV_32FC2);
-        src1.at<Point2f>(0,0) = Point2f(1,0);
-        src1.at<Point2f>(0,1) = Point2f(1,1);
-        src1.at<Point2f>(0,2) = Point2f(1,2);
+    Mat src1(1, 3, CV_32FC2);
+    src1.at<Point2f>(0,0) = Point2f(1,0);
+    src1.at<Point2f>(0,1) = Point2f(1,1);
+    src1.at<Point2f>(0,2) = Point2f(1,2);
 
-        Mat mask(1, 3, CV_8U);
-        mask.at<uchar>(0,0) = 1;
-        mask.at<uchar>(0,1) = 0;
-        mask.at<uchar>(0,2) = 1;
+    Mat mask(1, 3, CV_8U);
+    mask.at<uchar>(0,0) = 1;
+    mask.at<uchar>(0,1) = 0;
+    mask.at<uchar>(0,2) = 1;
 
-        gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
-        gpu::compactPoints(dsrc0, dsrc1, dmask);
+    gpu::GpuMat dsrc0(src0), dsrc1(src1), dmask(mask);
+    gpu::compactPoints(dsrc0, dsrc1, dmask);
 
-        dsrc0.download(src0);
-        dsrc1.download(src1);
+    dsrc0.download(src0);
+    dsrc1.download(src1);
 
-        ASSERT_EQ(2, src0.cols);
-        ASSERT_EQ(2, src1.cols);
+    ASSERT_EQ(2, src0.cols);
+    ASSERT_EQ(2, src1.cols);
 
-        ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
-        ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
+    ASSERT_TRUE(src0.at<Point2f>(0,0) == Point2f(0,0));
+    ASSERT_TRUE(src0.at<Point2f>(0,1) == Point2f(0,2));
 
-        ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
-        ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(src1.at<Point2f>(0,0) == Point2f(1,0));
+    ASSERT_TRUE(src1.at<Point2f>(0,1) == Point2f(1,2));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GlobalMotion, CompactPoints, ALL_DEVICES);
diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp
index fed954053..9d7e545de 100644
--- a/modules/gpu/test/test_gpumat.cpp
+++ b/modules/gpu/test/test_gpumat.cpp
@@ -69,122 +69,90 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(SetTo, Zero)
 {
-    try
-    {
-        cv::Scalar zero = cv::Scalar::all(0);
+    cv::Scalar zero = cv::Scalar::all(0);
 
-        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-        mat.setTo(zero);
+    cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+    mat.setTo(zero);
 
-        EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
 }
 
 TEST_P(SetTo, SameVal)
 {
-    try
-    {
-        cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
+    cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-
-            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
 }
 
 TEST_P(SetTo, DifferentVal)
 {
-    try
-    {
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
-        {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+    {
+        try
         {
             cv::gpu::GpuMat mat = createMat(size, type, useRoi);
             mat.setTo(val);
-
-            EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+        mat.setTo(val);
+
+        EXPECT_MAT_NEAR(cv::Mat(size, type, val), mat, 0.0);
     }
 }
 
 TEST_P(SetTo, Masked)
 {
-    try
+    cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat mat_gold = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Scalar val = randomScalar(0.0, 255.0);
-        cv::Mat mat_gold = randomMat(size, type);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat mat = createMat(size, type, useRoi);
-                mat.setTo(val, loadMat(mask));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
+            cv::gpu::GpuMat mat = createMat(size, type, useRoi);
+            mat.setTo(val, loadMat(mask));
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
-            mat.setTo(val, loadMat(mask, useRoi));
-
-            mat_gold.setTo(val, mask);
-
-            EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat mat = loadMat(mat_gold, useRoi);
+        mat.setTo(val, loadMat(mask, useRoi));
+
+        mat_gold.setTo(val, mask);
+
+        EXPECT_MAT_NEAR(mat_gold, mat, 0.0);
     }
 }
 
@@ -218,59 +186,43 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(CopyTo, WithOutMask)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        d_src.copyTo(dst);
+    cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    d_src.copyTo(dst);
 
-        EXPECT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(src, dst, 0.0);
 }
 
 TEST_P(CopyTo, Masked)
 {
-    try
+    cv::Mat src = randomMat(size, type);
+    cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
+
+    if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
-
-        if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.copyTo(dst, loadMat(mask, useRoi));
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
             d_src.copyTo(dst, loadMat(mask, useRoi));
-
-            cv::Mat dst_gold = cv::Mat::zeros(size, type);
-            src.copyTo(dst_gold, mask);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = loadMat(cv::Mat::zeros(size, type), useRoi);
+        d_src.copyTo(dst, loadMat(mask, useRoi));
+
+        cv::Mat dst_gold = cv::Mat::zeros(size, type);
+        src.copyTo(dst_gold, mask);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
@@ -305,79 +257,63 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
 
 TEST_P(ConvertTo, WithOutScaling)
 {
-    try
+    cv::Mat src = randomMat(size, depth1);
+
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth1);
-
-        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.convertTo(dst, depth2);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
             d_src.convertTo(dst, depth2);
-
-            cv::Mat dst_gold;
-            src.convertTo(dst_gold, depth2);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
     }
 }
 
 TEST_P(ConvertTo, WithScaling)
 {
-    try
+    cv::Mat src = randomMat(size, depth1);
+    double a = randomDouble(0.0, 1.0);
+    double b = randomDouble(-10.0, 10.0);
+
+    if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
-        cv::Mat src = randomMat(size, depth1);
-        double a = randomDouble(0.0, 1.0);
-        double b = randomDouble(-10.0, 10.0);
-
-        if ((depth1 == CV_64F || depth2 == CV_64F) && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
+        try
         {
-            try
-            {
-                cv::gpu::GpuMat d_src = loadMat(src);
-                cv::gpu::GpuMat dst;
-                d_src.convertTo(dst, depth2, a, b);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
-            }
-        }
-        else
-        {
-            cv::gpu::GpuMat d_src = loadMat(src, useRoi);
-            cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+            cv::gpu::GpuMat d_src = loadMat(src);
+            cv::gpu::GpuMat dst;
             d_src.convertTo(dst, depth2, a, b);
-
-            cv::Mat dst_gold;
-            src.convertTo(dst_gold, depth2, a, b);
-
-            EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsUnsupportedFormat, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat d_src = loadMat(src, useRoi);
+        cv::gpu::GpuMat dst = createMat(size, depth2, useRoi);
+        d_src.convertTo(dst, depth2, a, b);
+
+        cv::Mat dst_gold;
+        src.convertTo(dst_gold, depth2, a, b);
+
+        EXPECT_MAT_NEAR(dst_gold, dst, depth2 < CV_32F ? 1.0 : 1e-4);
     }
 }
 
@@ -402,30 +338,22 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(EnsureSizeIsEnough, BufferReuse)
 {
-    try
-    {
-        cv::gpu::GpuMat buffer(100, 100, CV_8U);
-        cv::gpu::GpuMat old = buffer;
+    cv::gpu::GpuMat buffer(100, 100, CV_8U);
+    cv::gpu::GpuMat old = buffer;
 
-        // don't reallocate memory
-        cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
-        EXPECT_EQ(10, buffer.rows);
-        EXPECT_EQ(20, buffer.cols);
-        EXPECT_EQ(CV_8UC1, buffer.type());
-        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(10, 20, CV_8U, buffer);
+    EXPECT_EQ(10, buffer.rows);
+    EXPECT_EQ(20, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
 
-        // don't reallocate memory
-        cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
-        EXPECT_EQ(20, buffer.rows);
-        EXPECT_EQ(30, buffer.cols);
-        EXPECT_EQ(CV_8UC1, buffer.type());
-        EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    // don't reallocate memory
+    cv::gpu::ensureSizeIsEnough(20, 30, CV_8U, buffer);
+    EXPECT_EQ(20, buffer.rows);
+    EXPECT_EQ(30, buffer.cols);
+    EXPECT_EQ(CV_8UC1, buffer.type());
+    EXPECT_EQ(reinterpret_cast<intptr_t>(old.data), reinterpret_cast<intptr_t>(buffer.data));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp
index 76ed0c618..c418d6ad7 100644
--- a/modules/gpu/test/test_hough.cpp
+++ b/modules/gpu/test/test_hough.cpp
@@ -81,36 +81,28 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughLines, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const bool useRoi = GET_PARAM(2);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(2);
 
-        const float rho = 1.0f;
-        const float theta = (float) (1.5 * CV_PI / 180.0);
-        const int threshold = 100;
+    const float rho = 1.0f;
+    const float theta = (float) (1.5 * CV_PI / 180.0);
+    onst int threshold = 100;
 
-        cv::Mat src(size, CV_8UC1);
-        generateLines(src);
+    cv::Mat src(size, CV_8UC1);
+    generateLines(src);
 
-        cv::gpu::GpuMat d_lines;
-        cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
+    cv::gpu::GpuMat d_lines;
+    cv::gpu::HoughLines(loadMat(src, useRoi), d_lines, rho, theta, threshold);
 
-        std::vector<cv::Vec2f> lines;
-        cv::gpu::HoughLinesDownload(d_lines, lines);
+    std::vector<cv::Vec2f> lines;
+    cv::gpu::HoughLinesDownload(d_lines, lines);
 
-        cv::Mat dst(size, CV_8UC1);
-        drawLines(dst, lines);
+    cv::Mat dst(size, CV_8UC1);
+    drawLines(dst, lines);
 
-        ASSERT_MAT_NEAR(src, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_MAT_NEAR(src, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HoughLines, testing::Combine(
@@ -134,61 +126,53 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(HoughCircles, Accuracy)
 {
-    try
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(2);
+
+    const float dp = 2.0f;
+    const float minDist = 10.0f;
+    const int minRadius = 10;
+    const int maxRadius = 20;
+    const int cannyThreshold = 100;
+    const int votesThreshold = 20;
+
+    std::vector<cv::Vec3f> circles_gold(4);
+    circles_gold[0] = cv::Vec3i(20, 20, minRadius);
+    circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
+    circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
+    circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
+
+    cv::Mat src(size, CV_8UC1);
+    drawCircles(src, circles_gold, true);
+
+    cv::gpu::GpuMat d_circles;
+    cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
+
+    std::vector<cv::Vec3f> circles;
+    cv::gpu::HoughCirclesDownload(d_circles, circles);
+
+    ASSERT_FALSE(circles.empty());
+
+    for (size_t i = 0; i < circles.size(); ++i)
     {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const bool useRoi = GET_PARAM(2);
+        cv::Vec3f cur = circles[i];
 
-        const float dp = 2.0f;
-        const float minDist = 10.0f;
-        const int minRadius = 10;
-        const int maxRadius = 20;
-        const int cannyThreshold = 100;
-        const int votesThreshold = 20;
+        bool found = false;
 
-        std::vector<cv::Vec3f> circles_gold(4);
-        circles_gold[0] = cv::Vec3i(20, 20, minRadius);
-        circles_gold[1] = cv::Vec3i(90, 87, minRadius + 3);
-        circles_gold[2] = cv::Vec3i(30, 70, minRadius + 8);
-        circles_gold[3] = cv::Vec3i(80, 10, maxRadius);
-
-        cv::Mat src(size, CV_8UC1);
-        drawCircles(src, circles_gold, true);
-
-        cv::gpu::GpuMat d_circles;
-        cv::gpu::HoughCircles(loadMat(src, useRoi), d_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
-
-        std::vector<cv::Vec3f> circles;
-        cv::gpu::HoughCirclesDownload(d_circles, circles);
-
-        ASSERT_FALSE(circles.empty());
-
-        for (size_t i = 0; i < circles.size(); ++i)
+        for (size_t j = 0; j < circles_gold.size(); ++j)
         {
-            cv::Vec3f cur = circles[i];
+            cv::Vec3f gold = circles_gold[j];
 
-            bool found = false;
-
-            for (size_t j = 0; j < circles_gold.size(); ++j)
+            if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
             {
-                cv::Vec3f gold = circles_gold[j];
-
-                if (std::fabs(cur[0] - gold[0]) < minDist && std::fabs(cur[1] - gold[1]) < minDist && std::fabs(cur[2] - gold[2]) < minDist)
-                {
-                    found = true;
-                    break;
-                }
+                found = true;
+                break;
             }
-
-            ASSERT_TRUE(found);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        ASSERT_TRUE(found);
     }
 }
 
@@ -206,68 +190,60 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(GeneralizedHough, POSITION)
 {
-    try
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const bool useRoi = GET_PARAM(1);
+
+    cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(templ.empty());
+
+    cv::Point templCenter(templ.cols / 2, templ.rows / 2);
+
+    const size_t gold_count = 3;
+    cv::Point pos_gold[gold_count];
+    pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
+    pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
+    pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
+
+    cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
+    for (size_t i = 0; i < gold_count; ++i)
     {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const bool useRoi = GET_PARAM(1);
-
-        cv::Mat templ = readImage("../cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(templ.empty());
-
-        cv::Point templCenter(templ.cols / 2, templ.rows / 2);
-
-        const size_t gold_count = 3;
-        cv::Point pos_gold[gold_count];
-        pos_gold[0] = cv::Point(templCenter.x + 10, templCenter.y + 10);
-        pos_gold[1] = cv::Point(2 * templCenter.x + 40, templCenter.y + 10);
-        pos_gold[2] = cv::Point(2 * templCenter.x + 40, 2 * templCenter.y + 40);
-
-        cv::Mat image(templ.rows * 3, templ.cols * 3, CV_8UC1, cv::Scalar::all(0));
-        for (size_t i = 0; i < gold_count; ++i)
-        {
-            cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
-            cv::Mat imageROI = image(rec);
-            templ.copyTo(imageROI);
-        }
-
-        cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
-        hough->set("votesThreshold", 200);
-
-        hough->setTemplate(loadMat(templ, useRoi));
-
-        cv::gpu::GpuMat d_pos;
-        hough->detect(loadMat(image, useRoi), d_pos);
-
-        std::vector<cv::Vec4f> pos;
-        hough->download(d_pos, pos);
-
-        ASSERT_EQ(gold_count, pos.size());
-
-        for (size_t i = 0; i < gold_count; ++i)
-        {
-            cv::Point gold = pos_gold[i];
-
-            bool found = false;
-
-            for (size_t j = 0; j < pos.size(); ++j)
-            {
-                cv::Point2f p(pos[j][0], pos[j][1]);
-
-                if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
-                {
-                    found = true;
-                    break;
-                }
-            }
-
-            ASSERT_TRUE(found);
-        }
+        cv::Rect rec(pos_gold[i].x - templCenter.x, pos_gold[i].y - templCenter.y, templ.cols, templ.rows);
+        cv::Mat imageROI = image(rec);
+        templ.copyTo(imageROI);
     }
-    catch (...)
+
+    cv::Ptr<cv::gpu::GeneralizedHough_GPU> hough = cv::gpu::GeneralizedHough_GPU::create(cv::GHT_POSITION);
+    hough->set("votesThreshold", 200);
+
+    hough->setTemplate(loadMat(templ, useRoi));
+
+    cv::gpu::GpuMat d_pos;
+    hough->detect(loadMat(image, useRoi), d_pos);
+
+    std::vector<cv::Vec4f> pos;
+    hough->download(d_pos, pos);
+
+    ASSERT_EQ(gold_count, pos.size());
+
+    for (size_t i = 0; i < gold_count; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Point gold = pos_gold[i];
+
+        bool found = false;
+
+        for (size_t j = 0; j < pos.size(); ++j)
+        {
+            cv::Point2f p(pos[j][0], pos[j][1]);
+
+            if (::fabs(p.x - gold.x) < 2 && ::fabs(p.y - gold.y) < 2)
+            {
+                found = true;
+                break;
+            }
+        }
+
+        ASSERT_TRUE(found);
     }
 }
 
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index 9de380810..71d4a8e65 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -66,23 +66,15 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
 
 TEST_P(Integral, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
-        cv::gpu::integral(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size(src.cols + 1, src.rows + 1), CV_32SC1, useRoi);
+    cv::gpu::integral(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::integral(src, dst_gold, CV_32S);
+    cv::Mat dst_gold;
+    cv::integral(src, dst_gold, CV_32S);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Integral, testing::Combine(
@@ -107,40 +99,32 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(HistEven, Accuracy)
 {
-    try
-    {
-        cv::Mat img = readImage("stereobm/aloe-L.png");
-        ASSERT_FALSE(img.empty());
+    cv::Mat img = readImage("stereobm/aloe-L.png");
+    ASSERT_FALSE(img.empty());
 
-        cv::Mat hsv;
-        cv::cvtColor(img, hsv, CV_BGR2HSV);
+    cv::Mat hsv;
+    cv::cvtColor(img, hsv, CV_BGR2HSV);
 
-        int hbins = 30;
-        float hranges[] = {0.0f, 180.0f};
+    int hbins = 30;
+    float hranges[] = {0.0f, 180.0f};
 
-        std::vector<cv::gpu::GpuMat> srcs;
-        cv::gpu::split(loadMat(hsv), srcs);
+    std::vector<cv::gpu::GpuMat> srcs;
+    cv::gpu::split(loadMat(hsv), srcs);
 
-        cv::gpu::GpuMat hist;
-        cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
+    cv::gpu::GpuMat hist;
+    cv::gpu::histEven(srcs[0], hist, hbins, (int)hranges[0], (int)hranges[1]);
 
-        cv::MatND histnd;
-        int histSize[] = {hbins};
-        const float* ranges[] = {hranges};
-        int channels[] = {0};
-        cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
+    cv::MatND histnd;
+    int histSize[] = {hbins};
+    const float* ranges[] = {hranges};
+    int channels[] = {0};
+    cv::calcHist(&hsv, 1, channels, cv::Mat(), histnd, 1, histSize, ranges);
 
-        cv::Mat hist_gold = histnd;
-        hist_gold = hist_gold.t();
-        hist_gold.convertTo(hist_gold, CV_32S);
+    cv::Mat hist_gold = histnd;
+    hist_gold = hist_gold.t();
+    hist_gold.convertTo(hist_gold, CV_32S);
 
-        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
@@ -180,23 +164,15 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(CalcHist, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat hist;
-        cv::gpu::calcHist(loadMat(src), hist);
+    cv::gpu::GpuMat hist;
+    cv::gpu::calcHist(loadMat(src), hist);
 
-        cv::Mat hist_gold;
-        calcHistGold(src, hist_gold);
+    cv::Mat hist_gold;
+    calcHistGold(src, hist_gold);
 
-        EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(hist_gold, hist, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CalcHist, testing::Combine(
@@ -222,23 +198,15 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(EqualizeHist, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_8UC1);
+    cv::Mat src = randomMat(size, CV_8UC1);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::equalizeHist(loadMat(src), dst);
+    cv::gpu::GpuMat dst;
+    cv::gpu::equalizeHist(loadMat(src), dst);
 
-        cv::Mat dst_gold;
-        cv::equalizeHist(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::equalizeHist(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 3.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, EqualizeHist, testing::Combine(
@@ -264,36 +232,28 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
 
 TEST_P(ColumnSum, Accuracy)
 {
-    try
+    cv::Mat src = randomMat(size, CV_32FC1);
+
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::columnSum(loadMat(src), d_dst);
+
+    cv::Mat dst(d_dst);
+
+    for (int j = 0; j < src.cols; ++j)
     {
-        cv::Mat src = randomMat(size, CV_32FC1);
-
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::columnSum(loadMat(src), d_dst);
-
-        cv::Mat dst(d_dst);
+        float gold = src.at<float>(0, j);
+        float res = dst.at<float>(0, j);
+        ASSERT_NEAR(res, gold, 1e-5);
+    }
 
+    for (int i = 1; i < src.rows; ++i)
+    {
         for (int j = 0; j < src.cols; ++j)
         {
-            float gold = src.at<float>(0, j);
-            float res = dst.at<float>(0, j);
+            float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
+            float res = dst.at<float>(i, j);
             ASSERT_NEAR(res, gold, 1e-5);
         }
-
-        for (int i = 1; i < src.rows; ++i)
-        {
-            for (int j = 0; j < src.cols; ++j)
-            {
-                float gold = src.at<float>(i, j) += src.at<float>(i - 1, j);
-                float res = dst.at<float>(i, j);
-                ASSERT_NEAR(res, gold, 1e-5);
-            }
-        }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
 }
 
@@ -327,41 +287,33 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
 
 TEST_P(Canny, Accuracy)
 {
-    try
+    cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(img.empty());
+
+    double low_thresh = 50.0;
+    double high_thresh = 100.0;
+
+    if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
     {
-        cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(img.empty());
-
-        double low_thresh = 50.0;
-        double high_thresh = 100.0;
-
-        if (!supportFeature(devInfo, cv::gpu::SHARED_ATOMICS))
+        try
         {
-            try
-            {
-            cv::gpu::GpuMat edges;
-            cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-            }
-            catch (const cv::Exception& e)
-            {
-                ASSERT_EQ(CV_StsNotImplemented, e.code);
-            }
+        cv::gpu::GpuMat edges;
+        cv::gpu::Canny(loadMat(img), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
         }
-        else
+        catch (const cv::Exception& e)
         {
-            cv::gpu::GpuMat edges;
-            cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-            cv::Mat edges_gold;
-            cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
-
-            EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
         }
     }
-    catch (...)
+    else
     {
-        cv::gpu::resetDevice();
-        throw;
+        cv::gpu::GpuMat edges;
+        cv::gpu::Canny(loadMat(img, useRoi), edges, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+        cv::Mat edges_gold;
+        cv::Canny(img, edges_gold, low_thresh, high_thresh, apperture_size, useL2gradient);
+
+        EXPECT_MAT_SIMILAR(edges_gold, edges, 2e-2);
     }
 }
 
@@ -399,66 +351,50 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(MeanShift, Filtering)
 {
-    try
-    {
-        cv::Mat img_template;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            img_template = readImage("meanshift/con_result.png");
-        else
-            img_template = readImage("meanshift/con_result_CC1X.png");
-        ASSERT_FALSE(img_template.empty());
+    cv::Mat img_template;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        img_template = readImage("meanshift/con_result.png");
+    else
+        img_template = readImage("meanshift/con_result_CC1X.png");
+    ASSERT_FALSE(img_template.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::meanShiftFiltering(loadMat(img), d_dst, spatialRad, colorRad);
 
-        ASSERT_EQ(CV_8UC4, d_dst.type());
+    ASSERT_EQ(CV_8UC4, d_dst.type());
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        cv::Mat result;
-        cv::cvtColor(dst, result, CV_BGRA2BGR);
+    cv::Mat result;
+    cv::cvtColor(dst, result, CV_BGRA2BGR);
 
-        EXPECT_MAT_NEAR(img_template, result, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(img_template, result, 0.0);
 }
 
 TEST_P(MeanShift, Proc)
 {
-    try
-    {
-        cv::FileStorage fs;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
-        else
-            fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap.yaml", cv::FileStorage::READ);
+    else
+        fs.open(std::string(cvtest::TS::ptr()->get_data_path()) + "meanshift/spmap_CC1X.yaml", cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        cv::Mat spmap_template;
-        fs["spmap"] >> spmap_template;
-        ASSERT_FALSE(spmap_template.empty());
+    cv::Mat spmap_template;
+    fs["spmap"] >> spmap_template;
+    ASSERT_FALSE(spmap_template.empty());
 
-        cv::gpu::GpuMat rmap_filtered;
-        cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
+    cv::gpu::GpuMat rmap_filtered;
+    cv::gpu::meanShiftFiltering(loadMat(img), rmap_filtered, spatialRad, colorRad);
 
-        cv::gpu::GpuMat rmap;
-        cv::gpu::GpuMat spmap;
-        cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
+    cv::gpu::GpuMat rmap;
+    cv::gpu::GpuMat spmap;
+    cv::gpu::meanShiftProc(loadMat(img), rmap, spmap, spatialRad, colorRad);
 
-        ASSERT_EQ(CV_8UC4, rmap.type());
+    ASSERT_EQ(CV_8UC4, rmap.type());
 
-        EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
-        EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(rmap_filtered, rmap, 0.0);
+    EXPECT_MAT_NEAR(spmap_template, spmap, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
@@ -484,33 +420,25 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
 
 TEST_P(MeanShiftSegmentation, Regression)
 {
-    try
-    {
-        cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
-        ASSERT_FALSE(img.empty());
+    cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
+    ASSERT_FALSE(img.empty());
 
-        std::ostringstream path;
-        path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
-        if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
-            path << ".png";
-        else
-            path << "_CC1X.png";
-        cv::Mat dst_gold = readImage(path.str());
-        ASSERT_FALSE(dst_gold.empty());
+    std::ostringstream path;
+    path << "meanshift/cones_segmented_sp10_sr10_minsize" << minsize;
+    if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
+        path << ".png";
+    else
+        path << "_CC1X.png";
+    cv::Mat dst_gold = readImage(path.str());
+    ASSERT_FALSE(dst_gold.empty());
 
-        cv::Mat dst;
-        cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
+    cv::Mat dst;
+    cv::gpu::meanShiftSegmentation(loadMat(img), dst, 10, 10, minsize);
 
-        cv::Mat dst_rgb;
-        cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
+    cv::Mat dst_rgb;
+    cv::cvtColor(dst, dst_rgb, CV_BGRA2BGR);
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst_rgb, 1e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
@@ -564,31 +492,23 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(Blend, Accuracy)
 {
-    try
-    {
-        int depth = CV_MAT_DEPTH(type);
+    int depth = CV_MAT_DEPTH(type);
 
-        cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-        cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
-        cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
-        cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
+    cv::Mat img1 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+    cv::Mat img2 = randomMat(size, type, 0.0, depth == CV_8U ? 255.0 : 1.0);
+    cv::Mat weights1 = randomMat(size, CV_32F, 0, 1);
+    cv::Mat weights2 = randomMat(size, CV_32F, 0, 1);
 
-        cv::gpu::GpuMat result;
-        cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
+    cv::gpu::GpuMat result;
+    cv::gpu::blendLinear(loadMat(img1, useRoi), loadMat(img2, useRoi), loadMat(weights1, useRoi), loadMat(weights2, useRoi), result);
 
-        cv::Mat result_gold;
-        if (depth == CV_8U)
-            blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
-        else
-            blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
+    cv::Mat result_gold;
+    if (depth == CV_8U)
+        blendLinearGold<uchar>(img1, img2, weights1, weights2, result_gold);
+    else
+        blendLinearGold<float>(img1, img2, weights1, weights2, result_gold);
 
-        EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(result_gold, result, CV_MAT_DEPTH(type) == CV_8U ? 1.0 : 1e-5);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
@@ -662,24 +582,16 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
 
 TEST_P(Convolve, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
-        cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
+    cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
+    cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
+    cv::gpu::GpuMat dst;
+    cv::gpu::convolve(loadMat(src), loadMat(kernel), dst, ccorr);
 
-        cv::Mat dst_gold;
-        convolveDFT(src, kernel, dst_gold, ccorr);
+    cv::Mat dst_gold;
+    convolveDFT(src, kernel, dst_gold, ccorr);
 
-        EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst, dst_gold, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
@@ -718,24 +630,16 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
 
 TEST_P(MatchTemplate8U, Accuracy)
 {
-    try
-    {
-        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
-        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
+    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
+    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+    cv::gpu::GpuMat dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-        cv::Mat dst_gold;
-        cv::matchTemplate(image, templ, dst_gold, method);
+    cv::Mat dst_gold;
+    cv::matchTemplate(image, templ, dst_gold, method);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate8U, testing::Combine(
@@ -772,24 +676,16 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
 
 TEST_P(MatchTemplate32F, Regression)
 {
-    try
-    {
-        cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
-        cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
+    cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
+    cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
+    cv::gpu::GpuMat dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(templ), dst, method);
 
-        cv::Mat dst_gold;
-        cv::matchTemplate(image, templ, dst_gold, method);
+    cv::Mat dst_gold;
+    cv::matchTemplate(image, templ, dst_gold, method);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, templ_size.area() * 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate32F, testing::Combine(
@@ -818,32 +714,24 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
 
 TEST_P(MatchTemplateBlackSource, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage("matchtemplate/black.png");
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage("matchtemplate/black.png");
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat pattern = readImage("matchtemplate/cat.png");
-        ASSERT_FALSE(pattern.empty());
+    cv::Mat pattern = readImage("matchtemplate/cat.png");
+    ASSERT_FALSE(pattern.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, method);
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        double maxValue;
-        cv::Point maxLoc;
-        cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
+    double maxValue;
+    cv::Point maxLoc;
+    cv::minMaxLoc(dst, NULL, &maxValue, NULL, &maxLoc);
 
-        cv::Point maxLocGold = cv::Point(284, 12);
+    cv::Point maxLocGold = cv::Point(284, 12);
 
-        ASSERT_EQ(maxLocGold, maxLoc);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(maxLocGold, maxLoc);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplateBlackSource, testing::Combine(
@@ -871,40 +759,32 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
 
 TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
 {
-    try
-    {
-        cv::Mat image = readImage(imageName);
-        ASSERT_FALSE(image.empty());
+    cv::Mat image = readImage(imageName);
+    ASSERT_FALSE(image.empty());
 
-        cv::Mat pattern = readImage(patternName);
-        ASSERT_FALSE(pattern.empty());
+    cv::Mat pattern = readImage(patternName);
+    ASSERT_FALSE(pattern.empty());
 
-        cv::gpu::GpuMat d_dst;
-        cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
+    cv::gpu::GpuMat d_dst;
+    cv::gpu::matchTemplate(loadMat(image), loadMat(pattern), d_dst, CV_TM_CCOEFF_NORMED);
 
-        cv::Mat dst(d_dst);
+    cv::Mat dst(d_dst);
 
-        cv::Point minLoc, maxLoc;
-        double minVal, maxVal;
-        cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
+    cv::Point minLoc, maxLoc;
+    double minVal, maxVal;
+    cv::minMaxLoc(dst, &minVal, &maxVal, &minLoc, &maxLoc);
 
-        cv::Mat dstGold;
-        cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
+    cv::Mat dstGold;
+    cv::matchTemplate(image, pattern, dstGold, CV_TM_CCOEFF_NORMED);
 
-        double minValGold, maxValGold;
-        cv::Point minLocGold, maxLocGold;
-        cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
+    double minValGold, maxValGold;
+    cv::Point minLocGold, maxLocGold;
+    cv::minMaxLoc(dstGold, &minValGold, &maxValGold, &minLocGold, &maxLocGold);
 
-        ASSERT_EQ(minLocGold, minLoc);
-        ASSERT_EQ(maxLocGold, maxLoc);
-        ASSERT_LE(maxVal, 1.0);
-        ASSERT_GE(minVal, -1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_EQ(minLocGold, minLoc);
+    ASSERT_EQ(maxLocGold, maxLoc);
+    ASSERT_LE(maxVal, 1.0);
+    ASSERT_GE(minVal, -1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CCOEF_NORMED, testing::Combine(
@@ -928,63 +808,47 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
 {
-    try
-    {
-        cv::Mat scene = readImage("matchtemplate/scene.png");
-        ASSERT_FALSE(scene.empty());
+    cv::Mat scene = readImage("matchtemplate/scene.png");
+    ASSERT_FALSE(scene.empty());
 
-        cv::Mat templ = readImage("matchtemplate/template.png");
-        ASSERT_FALSE(templ.empty());
+    cv::Mat templ = readImage("matchtemplate/template.png");
+    ASSERT_FALSE(templ.empty());
 
-        cv::gpu::GpuMat d_result;
-        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
+    cv::gpu::GpuMat d_result;
+    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF_NORMED);
 
-        cv::Mat result(d_result);
+    cv::Mat result(d_result);
 
-        double minVal;
-        cv::Point minLoc;
-        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+    double minVal;
+    cv::Point minLoc;
+    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-        ASSERT_GE(minVal, 0);
-        ASSERT_LT(minVal, 1e-3);
-        ASSERT_EQ(344, minLoc.x);
-        ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_GE(minVal, 0);
+    ASSERT_LT(minVal, 1e-3);
+    ASSERT_EQ(344, minLoc.x);
+    ASSERT_EQ(0, minLoc.y);
 }
 
 TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
 {
-    try
-    {
-        cv::Mat scene = readImage("matchtemplate/scene.png");
-        ASSERT_FALSE(scene.empty());
+    cv::Mat scene = readImage("matchtemplate/scene.png");
+    ASSERT_FALSE(scene.empty());
 
-        cv::Mat templ = readImage("matchtemplate/template.png");
-        ASSERT_FALSE(templ.empty());
+    cv::Mat templ = readImage("matchtemplate/template.png");
+    ASSERT_FALSE(templ.empty());
 
-        cv::gpu::GpuMat d_result;
-        cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
+    cv::gpu::GpuMat d_result;
+    cv::gpu::matchTemplate(loadMat(scene), loadMat(templ), d_result, CV_TM_SQDIFF);
 
-        cv::Mat result(d_result);
+    cv::Mat result(d_result);
 
-        double minVal;
-        cv::Point minLoc;
-        cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
+    double minVal;
+    cv::Point minLoc;
+    cv::minMaxLoc(result, &minVal, 0, &minLoc, 0);
 
-        ASSERT_GE(minVal, 0);
-        ASSERT_EQ(344, minLoc.x);
-        ASSERT_EQ(0, minLoc.y);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_GE(minVal, 0);
+    ASSERT_EQ(344, minLoc.x);
+    ASSERT_EQ(0, minLoc.y);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MatchTemplate_CanFindBigTemplate, ALL_DEVICES);
@@ -1017,43 +881,27 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
 
 TEST_P(MulSpectrums, Simple)
 {
-    try
-    {
-        cv::gpu::GpuMat c;
-        cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
+    cv::gpu::GpuMat c;
+    cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
 
-        cv::Mat c_gold;
-        cv::mulSpectrums(a, b, c_gold, flag, false);
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
 
-        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
 }
 
 TEST_P(MulSpectrums, Scaled)
 {
-    try
-    {
-        float scale = 1.f / size.area();
+    float scale = 1.f / size.area();
 
-        cv::gpu::GpuMat c;
-        cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
+    cv::gpu::GpuMat c;
+    cv::gpu::mulAndScaleSpectrums(loadMat(a), loadMat(b), c, flag, scale, false);
 
-        cv::Mat c_gold;
-        cv::mulSpectrums(a, b, c_gold, flag, false);
-        c_gold.convertTo(c_gold, c_gold.type(), scale);
+    cv::Mat c_gold;
+    cv::mulSpectrums(a, b, c_gold, flag, false);
+    c_gold.convertTo(c_gold, c_gold.type(), scale);
 
-        EXPECT_MAT_NEAR(c_gold, c, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(c_gold, c, 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MulSpectrums, testing::Combine(
@@ -1102,34 +950,26 @@ void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplac
 
 TEST_P(Dft, C2C)
 {
-    try
-    {
-        int cols = randomInt(2, 100);
-        int rows = randomInt(2, 100);
+    int cols = randomInt(2, 100);
+    int rows = randomInt(2, 100);
 
-        for (int i = 0; i < 2; ++i)
-        {
-            bool inplace = i != 0;
-
-            testC2C("no flags", cols, rows, 0, inplace);
-            testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
-            testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
-            testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
-            testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
-            testC2C("single col", 1, rows, 0, inplace);
-            testC2C("single row", cols, 1, 0, inplace);
-            testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
-            testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
-            testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
-            testC2C("size 1 2", 1, 2, 0, inplace);
-            testC2C("size 2 1", 2, 1, 0, inplace);
-        }
-    }
-    catch (...)
+    for (int i = 0; i < 2; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        bool inplace = i != 0;
+
+        testC2C("no flags", cols, rows, 0, inplace);
+        testC2C("no flags 0 1", cols, rows + 1, 0, inplace);
+        testC2C("no flags 1 0", cols, rows + 1, 0, inplace);
+        testC2C("no flags 1 1", cols + 1, rows, 0, inplace);
+        testC2C("DFT_INVERSE", cols, rows, cv::DFT_INVERSE, inplace);
+        testC2C("DFT_ROWS", cols, rows, cv::DFT_ROWS, inplace);
+        testC2C("single col", 1, rows, 0, inplace);
+        testC2C("single row", cols, 1, 0, inplace);
+        testC2C("single col inversed", 1, rows, cv::DFT_INVERSE, inplace);
+        testC2C("single row inversed", cols, 1, cv::DFT_INVERSE, inplace);
+        testC2C("single row DFT_ROWS", cols, 1, cv::DFT_ROWS, inplace);
+        testC2C("size 1 2", 1, 2, 0, inplace);
+        testC2C("size 2 1", 2, 1, 0, inplace);
     }
 }
 
@@ -1171,32 +1011,24 @@ void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
 
 TEST_P(Dft, R2CThenC2R)
 {
-    try
-    {
-        int cols = randomInt(2, 100);
-        int rows = randomInt(2, 100);
+    int cols = randomInt(2, 100);
+    int rows = randomInt(2, 100);
 
-        testR2CThenC2R("sanity", cols, rows, false);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
-        testR2CThenC2R("single col", 1, rows, false);
-        testR2CThenC2R("single col 1", 1, rows + 1, false);
-        testR2CThenC2R("single row", cols, 1, false);
-        testR2CThenC2R("single row 1", cols + 1, 1, false);
+    testR2CThenC2R("sanity", cols, rows, false);
+    testR2CThenC2R("sanity 0 1", cols, rows + 1, false);
+    testR2CThenC2R("sanity 1 0", cols + 1, rows, false);
+    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, false);
+    testR2CThenC2R("single col", 1, rows, false);
+    testR2CThenC2R("single col 1", 1, rows + 1, false);
+    testR2CThenC2R("single row", cols, 1, false);
+    testR2CThenC2R("single row 1", cols + 1, 1, false);
 
-        testR2CThenC2R("sanity", cols, rows, true);
-        testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
-        testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
-        testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
-        testR2CThenC2R("single row", cols, 1, true);
-        testR2CThenC2R("single row 1", cols + 1, 1, true);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    testR2CThenC2R("sanity", cols, rows, true);
+    testR2CThenC2R("sanity 0 1", cols, rows + 1, true);
+    testR2CThenC2R("sanity 1 0", cols + 1, rows, true);
+    testR2CThenC2R("sanity 1 1", cols + 1, rows + 1, true);
+    testR2CThenC2R("single row", cols, 1, true);
+    testR2CThenC2R("single row 1", cols + 1, 1, true);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
@@ -1229,26 +1061,18 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
 
 TEST_P(CornerHarris, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        double k = randomDouble(0.1, 0.9);
+    double k = randomDouble(0.1, 0.9);
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cornerHarris(loadMat(src), dst, blockSize, apertureSize, k, borderType);
 
-        cv::Mat dst_gold;
-        cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
+    cv::Mat dst_gold;
+    cv::cornerHarris(src, dst_gold, blockSize, apertureSize, k, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerHarris, testing::Combine(
@@ -1283,24 +1107,16 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
 
 TEST_P(CornerMinEigen, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobm/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobm/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
+    cv::gpu::GpuMat dst;
+    cv::gpu::cornerMinEigenVal(loadMat(src), dst, blockSize, apertureSize, borderType);
 
-        cv::Mat dst_gold;
-        cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
+    cv::Mat dst_gold;
+    cv::cornerMinEigenVal(src, dst_gold, blockSize, apertureSize, borderType);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.02);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
diff --git a/modules/gpu/test/test_labeling.cpp b/modules/gpu/test/test_labeling.cpp
index 21ee03bcf..68d2cf404 100644
--- a/modules/gpu/test/test_labeling.cpp
+++ b/modules/gpu/test/test_labeling.cpp
@@ -168,35 +168,27 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(Labeling, ConnectedComponents)
 {
-    try
-    {
-        cv::Mat image;
-        cvtColor(loat_image(), image, CV_BGR2GRAY);
+    cv::Mat image;
+    cvtColor(loat_image(), image, CV_BGR2GRAY);
 
-        cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
+    cv::threshold(image, image, 150, 255, CV_THRESH_BINARY);
 
-        ASSERT_TRUE(image.type() == CV_8UC1);
+    ASSERT_TRUE(image.type() == CV_8UC1);
 
-        GreedyLabeling host(image);
-        host(host._labels);
+    GreedyLabeling host(image);
+    host(host._labels);
 
-        cv::gpu::GpuMat mask;
-        mask.create(image.rows, image.cols, CV_8UC1);
+    cv::gpu::GpuMat mask;
+    mask.create(image.rows, image.cols, CV_8UC1);
 
-        cv::gpu::GpuMat components;
-        components.create(image.rows, image.cols, CV_32SC1);
+    cv::gpu::GpuMat components;
+    components.create(image.rows, image.cols, CV_32SC1);
 
-        cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
+    cv::gpu::connectivityMask(cv::gpu::GpuMat(image), mask, cv::Scalar::all(0), cv::Scalar::all(2));
 
-        ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
+    ASSERT_NO_THROW(cv::gpu::labelComponents(mask, components));
 
-        host.checkCorrectness(cv::Mat(components));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    host.checkCorrectness(cv::Mat(components));
 }
 
 INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);
diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp
index 0b844d35d..484f3cfbb 100644
--- a/modules/gpu/test/test_nvidia.cpp
+++ b/modules/gpu/test/test_nvidia.cpp
@@ -69,169 +69,82 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
 struct NPPST : NVidiaTest {};
 struct NCV : NVidiaTest {};
 
-TEST_P(NPPST, Integral)
-{
-    try
-    {
-        bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
+//TEST_P(NPPST, Integral)
+//{
+//    bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
-}
+//    ASSERT_TRUE(res);
+//}
 
 TEST_P(NPPST, SquaredIntegral)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, RectStdDev)
 {
-    try
-    {
-        bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Resize)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, VectorOperations)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NPPST, Transpose)
 {
-    try
-    {
-        bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, VectorOperations)
 {
-    try
-    {
-        bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeLoader)
 {
-    try
-    {
-        bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HaarCascadeApplication)
 {
-    try
-    {
-        bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, HypothesesFiltration)
 {
-    try
-    {
-        bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
+    bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 TEST_P(NCV, Visualization)
 {
-    try
-    {
-        bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
+    // this functionality doesn't used in gpu module
+    bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
 
-        ASSERT_TRUE(res);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(res);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_NVidia, NPPST, ALL_DEVICES);
diff --git a/modules/gpu/test/test_objdetect.cpp b/modules/gpu/test/test_objdetect.cpp
index 81c6c40ce..4fb295d4c 100644
--- a/modules/gpu/test/test_objdetect.cpp
+++ b/modules/gpu/test/test_objdetect.cpp
@@ -175,129 +175,114 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
     }
 };
 
-TEST_P(HOG, Detect)
+// desabled while resize does not fixed
+TEST_P(HOG, DISABLED_Detect)
 {
-    try
-    {
-        cv::Mat img_rgb = readImage("hog/road.png");
-        ASSERT_FALSE(img_rgb.empty());
+    cv::Mat img_rgb = readImage("hog/road.png");
+    ASSERT_FALSE(img_rgb.empty());
 
-    #ifdef DUMP
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
-    #else
-        f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
-        ASSERT_TRUE(f.is_open());
-    #endif
+#ifdef DUMP
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#else
+    f.open((std::string(cvtest::TS::ptr()->get_data_path()) + "hog/expected_output.bin").c_str(), std::ios_base::binary);
+    ASSERT_TRUE(f.is_open());
+#endif
 
-        // Test on color image
-        cv::Mat img;
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        testDetect(img);
+    // Test on color image
+    cv::Mat img;
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    testDetect(img);
 
-        // Test on gray image
-        cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
-        testDetect(img);
+    // Test on gray image
+    cv::cvtColor(img_rgb, img, CV_BGR2GRAY);
+    testDetect(img);
 
-        f.close();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    f.close();
 }
 
 TEST_P(HOG, GetDescriptors)
 {
-    try
+    // Load image (e.g. train data, composed from windows)
+    cv::Mat img_rgb = readImage("hog/train_data.png");
+    ASSERT_FALSE(img_rgb.empty());
+
+    // Convert to C4
+    cv::Mat img;
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+
+    cv::gpu::GpuMat d_img(img);
+
+    // Convert train images into feature vectors (train table)
+    cv::gpu::GpuMat descriptors, descriptors_by_cols;
+    getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
+    getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
+
+    // Check size of the result train table
+    wins_per_img_x = 3;
+    wins_per_img_y = 2;
+    blocks_per_win_x = 7;
+    blocks_per_win_y = 15;
+    block_hist_size = 36;
+    cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
+                                            wins_per_img_x * wins_per_img_y);
+    ASSERT_EQ(descr_size_expected, descriptors.size());
+
+    // Check both formats of output descriptors are handled correctly
+    cv::Mat dr(descriptors);
+    cv::Mat dc(descriptors_by_cols);
+    for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
     {
-        // Load image (e.g. train data, composed from windows)
-        cv::Mat img_rgb = readImage("hog/train_data.png");
-        ASSERT_FALSE(img_rgb.empty());
-
-        // Convert to C4
-        cv::Mat img;
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-
-        cv::gpu::GpuMat d_img(img);
-
-        // Convert train images into feature vectors (train table)
-        cv::gpu::GpuMat descriptors, descriptors_by_cols;
-        getDescriptors(d_img, win_size, descriptors, DESCR_FORMAT_ROW_BY_ROW);
-        getDescriptors(d_img, win_size, descriptors_by_cols, DESCR_FORMAT_COL_BY_COL);
-
-        // Check size of the result train table
-        wins_per_img_x = 3;
-        wins_per_img_y = 2;
-        blocks_per_win_x = 7;
-        blocks_per_win_y = 15;
-        block_hist_size = 36;
-        cv::Size descr_size_expected = cv::Size(blocks_per_win_x * blocks_per_win_y * block_hist_size,
-                                                wins_per_img_x * wins_per_img_y);
-        ASSERT_EQ(descr_size_expected, descriptors.size());
-
-        // Check both formats of output descriptors are handled correctly
-        cv::Mat dr(descriptors);
-        cv::Mat dc(descriptors_by_cols);
-        for (int i = 0; i < wins_per_img_x * wins_per_img_y; ++i)
-        {
-            const float* l = dr.rowRange(i, i + 1).ptr<float>();
-            const float* r = dc.rowRange(i, i + 1).ptr<float>();
-            for (int y = 0; y < blocks_per_win_y; ++y)
-                for (int x = 0; x < blocks_per_win_x; ++x)
-                    for (int k = 0; k < block_hist_size; ++k)
-                        ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
-                                  r[(x * blocks_per_win_y + y) * block_hist_size + k]);
-        }
-
-        /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
-        be defferent, due to border values interpolation. Using of many small images is slower, however we
-        wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
-        works good, it can be checked in the gpu_hog sample */
-
-        img_rgb = readImage("hog/positive1.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        // Everything is fine with interpolation for left top subimage
-        ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
-
-        img_rgb = readImage("hog/positive2.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
-
-        img_rgb = readImage("hog/negative1.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
-
-        img_rgb = readImage("hog/negative2.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
-
-        img_rgb = readImage("hog/positive3.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
-
-        img_rgb = readImage("hog/negative3.png");
-        ASSERT_TRUE(!img_rgb.empty());
-        cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
-        computeBlockHistograms(cv::gpu::GpuMat(img));
-        compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        const float* l = dr.rowRange(i, i + 1).ptr<float>();
+        const float* r = dc.rowRange(i, i + 1).ptr<float>();
+        for (int y = 0; y < blocks_per_win_y; ++y)
+            for (int x = 0; x < blocks_per_win_x; ++x)
+                for (int k = 0; k < block_hist_size; ++k)
+                    ASSERT_EQ(l[(y * blocks_per_win_x + x) * block_hist_size + k],
+                              r[(x * blocks_per_win_y + y) * block_hist_size + k]);
     }
+
+    /* Now we want to extract the same feature vectors, but from single images. NOTE: results will
+    be defferent, due to border values interpolation. Using of many small images is slower, however we
+    wont't call getDescriptors and will use computeBlockHistograms instead of. computeBlockHistograms
+    works good, it can be checked in the gpu_hog sample */
+
+    img_rgb = readImage("hog/positive1.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    // Everything is fine with interpolation for left top subimage
+    ASSERT_EQ(0.0, cv::norm((cv::Mat)block_hists, (cv::Mat)descriptors.rowRange(0, 1)));
+
+    img_rgb = readImage("hog/positive2.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(1, 2)));
+
+    img_rgb = readImage("hog/negative1.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(2, 3)));
+
+    img_rgb = readImage("hog/negative2.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(3, 4)));
+
+    img_rgb = readImage("hog/positive3.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(4, 5)));
+
+    img_rgb = readImage("hog/negative3.png");
+    ASSERT_TRUE(!img_rgb.empty());
+    cv::cvtColor(img_rgb, img, CV_BGR2BGRA);
+    computeBlockHistograms(cv::gpu::GpuMat(img));
+    compare_inner_parts(cv::Mat(block_hists), cv::Mat(descriptors.rowRange(5, 6)));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
@@ -320,35 +305,27 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
 
 TEST_P(CalTech, HOG)
 {
-    try
+    cv::gpu::GpuMat d_img(img);
+    cv::Mat markedImage(img.clone());
+
+    cv::gpu::HOGDescriptor d_hog;
+    d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
+    d_hog.nlevels = d_hog.nlevels + 32;
+
+    std::vector<cv::Rect> found_locations;
+    d_hog.detectMultiScale(d_img, found_locations);
+
+#if defined (LOG_CASCADE_STATISTIC)
+    for (int i = 0; i < (int)found_locations.size(); i++)
     {
-        cv::gpu::GpuMat d_img(img);
-        cv::Mat markedImage(img.clone());
+        cv::Rect r = found_locations[i];
 
-        cv::gpu::HOGDescriptor d_hog;
-        d_hog.setSVMDetector(cv::gpu::HOGDescriptor::getDefaultPeopleDetector());
-        d_hog.nlevels = d_hog.nlevels + 32;
-
-        std::vector<cv::Rect> found_locations;
-        d_hog.detectMultiScale(d_img, found_locations);
-
-    #if defined (LOG_CASCADE_STATISTIC)
-        for (int i = 0; i < (int)found_locations.size(); i++)
-        {
-            cv::Rect r = found_locations[i];
-
-            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
-        }
-
-        cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
     }
+
+    cv::imshow("Res", markedImage); cv::waitKey();
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(detect, CalTech, testing::Combine(ALL_DEVICES,
@@ -375,17 +352,9 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_Read_classifier, Accuracy)
 {
-    try
-    {
-        cv::gpu::CascadeClassifier_GPU classifier;
-        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-        ASSERT_TRUE(classifier.load(classifierXmlPath));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::gpu::CascadeClassifier_GPU classifier;
+    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+    ASSERT_TRUE(classifier.load(classifierXmlPath));
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_Read_classifier,
@@ -405,57 +374,49 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
 
 TEST_P(LBP_classify, Accuracy)
 {
-    try
+    std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
+    std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
+
+    cv::CascadeClassifier cpuClassifier(classifierXmlPath);
+    ASSERT_FALSE(cpuClassifier.empty());
+
+    cv::Mat image = cv::imread(imagePath);
+    image = image.colRange(0, image.cols/2);
+    cv::Mat grey;
+    cvtColor(image, grey, CV_BGR2GRAY);
+    ASSERT_FALSE(image.empty());
+
+    std::vector<cv::Rect> rects;
+    cpuClassifier.detectMultiScale(grey, rects);
+    cv::Mat markedImage = image.clone();
+
+    std::vector<cv::Rect>::iterator it = rects.begin();
+    for (; it != rects.end(); ++it)
+        cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
+
+    cv::gpu::CascadeClassifier_GPU gpuClassifier;
+    ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
+
+    cv::gpu::GpuMat gpu_rects;
+    cv::gpu::GpuMat tested(grey);
+    int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
+
+#if defined (LOG_CASCADE_STATISTIC)
+    cv::Mat downloaded(gpu_rects);
+    const cv::Rect* faces = downloaded.ptr<cv::Rect>();
+    for (int i = 0; i < count; i++)
     {
-        std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
-        std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
+        cv::Rect r = faces[i];
 
-        cv::CascadeClassifier cpuClassifier(classifierXmlPath);
-        ASSERT_FALSE(cpuClassifier.empty());
-
-        cv::Mat image = cv::imread(imagePath);
-        image = image.colRange(0, image.cols/2);
-        cv::Mat grey;
-        cvtColor(image, grey, CV_BGR2GRAY);
-        ASSERT_FALSE(image.empty());
-
-        std::vector<cv::Rect> rects;
-        cpuClassifier.detectMultiScale(grey, rects);
-        cv::Mat markedImage = image.clone();
-
-        std::vector<cv::Rect>::iterator it = rects.begin();
-        for (; it != rects.end(); ++it)
-            cv::rectangle(markedImage, *it, CV_RGB(0, 0, 255));
-
-        cv::gpu::CascadeClassifier_GPU gpuClassifier;
-        ASSERT_TRUE(gpuClassifier.load(classifierXmlPath));
-
-        cv::gpu::GpuMat gpu_rects;
-        cv::gpu::GpuMat tested(grey);
-        int count = gpuClassifier.detectMultiScale(tested, gpu_rects);
-
-    #if defined (LOG_CASCADE_STATISTIC)
-        cv::Mat downloaded(gpu_rects);
-        const cv::Rect* faces = downloaded.ptr<cv::Rect>();
-        for (int i = 0; i < count; i++)
-        {
-            cv::Rect r = faces[i];
-
-            std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
-            cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
-        }
-    #endif
-
-    #if defined (LOG_CASCADE_STATISTIC)
-        cv::imshow("Res", markedImage); cv::waitKey();
-    #endif
-        (void)count;
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        std::cout << r.x << " " << r.y  << " " << r.width << " " << r.height << std::endl;
+        cv::rectangle(markedImage, r , CV_RGB(255, 0, 0));
     }
+#endif
+
+#if defined (LOG_CASCADE_STATISTIC)
+    cv::imshow("Res", markedImage); cv::waitKey();
+#endif
+    (void)count;
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index 4be0c153a..3bb3e09ea 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -70,402 +70,258 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
 
 TEST_P(GlBuffer, Constructor1)
 {
-    try
-    {
-        cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, Constructor2)
 {
-    try
-    {
-        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, ConstructorFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, ConstructorFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
+    cv::GlBuffer buf(d_gold, cv::GlBuffer::ARRAY_BUFFER);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, ConstructorFromGlBuffer)
 {
-    try
-    {
-        cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer buf(buf_gold);
+    cv::GlBuffer buf(buf_gold);
 
-        EXPECT_EQ(buf_gold.bufId(), buf.bufId());
-        EXPECT_EQ(buf_gold.rows(), buf.rows());
-        EXPECT_EQ(buf_gold.cols(), buf.cols());
-        EXPECT_EQ(buf_gold.type(), buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(buf_gold.bufId(), buf.bufId());
+    EXPECT_EQ(buf_gold.rows(), buf.rows());
+    EXPECT_EQ(buf_gold.cols(), buf.cols());
+    EXPECT_EQ(buf_gold.type(), buf.type());
 }
 
 TEST_P(GlBuffer, ConstructorFromGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
-        cv::GlTexture2D tex_gold(gold, true);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold, true);
 
-        cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlBuffer buf(tex_gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 TEST_P(GlBuffer, Create)
 {
-    try
-    {
-        cv::GlBuffer buf;
-        buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_EQ(size.height, buf.rows());
-        EXPECT_EQ(size.width, buf.cols());
-        EXPECT_EQ(type, buf.type());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, buf.rows());
+    EXPECT_EQ(size.width, buf.cols());
+    EXPECT_EQ(type, buf.type());
 }
 
 TEST_P(GlBuffer, CopyFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(d_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::Mat gold = randomMat(size, type);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(buf_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf_gold.bufId(), buf.bufId());
+    EXPECT_NE(buf_gold.bufId(), buf.bufId());
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyFromGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
-        cv::GlTexture2D tex_gold(gold, true);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::GlTexture2D tex_gold(gold, true);
 
-        cv::GlBuffer buf;
-        buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf;
+    buf.copyFrom(tex_gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 TEST_P(GlBuffer, CopyToGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::gpu::GpuMat dst;
-        buf.copyTo(dst);
+    cv::gpu::GpuMat dst;
+    buf.copyTo(dst);
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, dst, 0);
 }
 
 TEST_P(GlBuffer, CopyToGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer dst;
-        buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer dst;
+    buf.copyTo(dst, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf.bufId(), dst.bufId());
+    EXPECT_NE(buf.bufId(), dst.bufId());
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, CopyToGlTexture2D)
 {
-    try
-    {
-        const int depth = CV_MAT_DEPTH(type);
-        const int cn = CV_MAT_CN(type);
+    const int depth = CV_MAT_DEPTH(type);
+    const int cn = CV_MAT_CN(type);
 
-        if (depth != CV_32F || cn == 2)
-            return;
+    if (depth != CV_32F || cn == 2)
+        return;
 
-        cv::Mat gold = randomMat(size, type, 0, 1.0);
+    cv::Mat gold = randomMat(size, type, 0, 1.0);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::GlTexture2D tex;
-        buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
+    cv::GlTexture2D tex;
+    buf.copyTo(tex, cv::GlBuffer::PIXEL_PACK_BUFFER, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData);
+    cv::Mat texData;
+    tex.copyTo(texData);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlBuffer, Clone)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer dst = buf.clone(cv::GlBuffer::ARRAY_BUFFER, true);
 
-        EXPECT_NE(buf.bufId(), dst.bufId());
+    EXPECT_NE(buf.bufId(), dst.bufId());
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, MapHostRead)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::READ_ONLY);
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
+    EXPECT_MAT_NEAR(gold, dst, 0);
 
-        buf.unmapHost();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    buf.unmapHost();
 }
 
 TEST_P(GlBuffer, MapHostWrite)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
-        gold.copyTo(dst);
-        buf.unmapHost();
-        dst.release();
+    cv::Mat dst = buf.mapHost(cv::GlBuffer::WRITE_ONLY);
+    gold.copyTo(dst);
+    buf.unmapHost();
+    dst.release();
 
-        cv::Mat bufData;
-        buf.copyTo(bufData);
+    cv::Mat bufData;
+    buf.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
 TEST_P(GlBuffer, MapDevice)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type);
+    cv::Mat gold = randomMat(size, type);
 
-        cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
+    cv::GlBuffer buf(gold, cv::GlBuffer::ARRAY_BUFFER, true);
 
-        cv::gpu::GpuMat dst = buf.mapDevice();
+    cv::gpu::GpuMat dst = buf.mapDevice();
 
-        EXPECT_MAT_NEAR(gold, dst, 0);
+    EXPECT_MAT_NEAR(gold, dst, 0);
 
-        buf.unmapDevice();
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    buf.unmapDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES));
@@ -504,243 +360,147 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
 
 TEST_P(GlTexture2D, Constructor1)
 {
-    try
-    {
-        cv::GlTexture2D tex(size.height, size.width, format, true);
+    cv::GlTexture2D tex(size.height, size.width, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, Constructor2)
 {
-    try
-    {
-        cv::GlTexture2D tex(size, format, true);
+    cv::GlTexture2D tex(size, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, ConstructorFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlTexture2D tex(d_gold, true);
+    cv::GlTexture2D tex(d_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-        cv::GlTexture2D tex(buf_gold, true);
+    cv::GlTexture2D tex(buf_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
 {
-    try
-    {
-        cv::GlTexture2D tex_gold(size, format, true);
-        cv::GlTexture2D tex(tex_gold);
+    cv::GlTexture2D tex_gold(size, format, true);
+    cv::GlTexture2D tex(tex_gold);
 
-        EXPECT_EQ(tex_gold.texId(), tex.texId());
-        EXPECT_EQ(tex_gold.rows(), tex.rows());
-        EXPECT_EQ(tex_gold.cols(), tex.cols());
-        EXPECT_EQ(tex_gold.format(), tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(tex_gold.texId(), tex.texId());
+    EXPECT_EQ(tex_gold.rows(), tex.rows());
+    EXPECT_EQ(tex_gold.cols(), tex.cols());
+    EXPECT_EQ(tex_gold.format(), tex.format());
 }
 
 TEST_P(GlTexture2D, Create)
 {
-    try
-    {
-        cv::GlTexture2D tex;
-        tex.create(size.height, size.width, format, true);
+    cv::GlTexture2D tex;
+    tex.create(size.height, size.width, format, true);
 
-        EXPECT_EQ(size.height, tex.rows());
-        EXPECT_EQ(size.width, tex.cols());
-        EXPECT_EQ(format, tex.format());
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_EQ(size.height, tex.rows());
+    EXPECT_EQ(size.width, tex.cols());
+    EXPECT_EQ(format, tex.format());
 }
 
 TEST_P(GlTexture2D, CopyFromMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyFromGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::gpu::GpuMat d_gold(gold);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::gpu::GpuMat d_gold(gold);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(d_gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(d_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyFromGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
-        cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
 
-        cv::GlTexture2D tex;
-        tex.copyFrom(buf_gold, true);
+    cv::GlTexture2D tex;
+    tex.copyFrom(buf_gold, true);
 
-        cv::Mat texData;
-        tex.copyTo(texData, depth);
+    cv::Mat texData;
+    tex.copyTo(texData, depth);
 
-        EXPECT_MAT_NEAR(gold, texData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyToGpuMat)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::gpu::GpuMat dst;
-        tex.copyTo(dst, depth);
+    cv::gpu::GpuMat dst;
+    tex.copyTo(dst, depth);
 
-        EXPECT_MAT_NEAR(gold, dst, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, dst, 1e-2);
 }
 
 TEST_P(GlTexture2D, CopyToGlBuffer)
 {
-    try
-    {
-        cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
+    cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
-        cv::GlTexture2D tex(gold, true);
+    cv::GlTexture2D tex(gold, true);
 
-        cv::GlBuffer dst;
-        tex.copyTo(dst, depth, true);
+    cv::GlBuffer dst;
+    tex.copyTo(dst, depth, true);
 
-        cv::Mat bufData;
-        dst.copyTo(bufData);
+    cv::Mat bufData;
+    dst.copyTo(bufData);
 
-        EXPECT_MAT_NEAR(gold, bufData, 1e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4)));
diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp
index ae91b192b..1abd7841e 100644
--- a/modules/gpu/test/test_pyramids.cpp
+++ b/modules/gpu/test/test_pyramids.cpp
@@ -66,23 +66,15 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrDown, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
-        cv::gpu::pyrDown(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size((size.width + 1) / 2, (size.height + 1) / 2), type, useRoi);
+    cv::gpu::pyrDown(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::pyrDown(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::pyrDown(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrDown, testing::Combine(
@@ -114,23 +106,15 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(PyrUp, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
-        cv::gpu::pyrUp(loadMat(src, useRoi), dst);
+    cv::gpu::GpuMat dst = createMat(cv::Size(size.width * 2, size.height * 2), type, useRoi);
+    cv::gpu::pyrUp(loadMat(src, useRoi), dst);
 
-        cv::Mat dst_gold;
-        cv::pyrUp(src, dst_gold);
+    cv::Mat dst_gold;
+    cv::pyrUp(src, dst_gold);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-4 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, PyrUp, testing::Combine(
diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp
index e8b44b5fe..978e1044a 100644
--- a/modules/gpu/test/test_remap.cpp
+++ b/modules/gpu/test/test_remap.cpp
@@ -154,24 +154,16 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
 
 TEST_P(Remap, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
-        cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
+    cv::gpu::GpuMat dst = createMat(xmap.size(), type, useRoi);
+    cv::gpu::remap(loadMat(src, useRoi), dst, loadMat(xmap, useRoi), loadMat(ymap, useRoi), interpolation, borderType, val);
 
-        cv::Mat dst_gold;
-        remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    remapGold(src, xmap, ymap, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-3 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Remap, testing::Combine(
diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp
index b1b30bb26..cae2dbf41 100644
--- a/modules/gpu/test/test_resize.cpp
+++ b/modules/gpu/test/test_resize.cpp
@@ -138,23 +138,15 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
 
 TEST_P(Resize, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        resizeGold(src, dst_gold, coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
@@ -192,23 +184,15 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
 // downscaling only: used for classifiers
 TEST_P(ResizeSameAsHost, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
+    cv::Mat src = randomMat(size, type);
 
-        cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
-        cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst = createMat(cv::Size(cv::saturate_cast<int>(src.cols * coeff), cv::saturate_cast<int>(src.rows * coeff)), type, useRoi);
+    cv::gpu::resize(loadMat(src, useRoi), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    cv::resize(src, dst_gold, cv::Size(), coeff, coeff, interpolation);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-2 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeSameAsHost, testing::Combine(
@@ -242,24 +226,16 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
 
 TEST_P(ResizeNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        ASSERT_FALSE(src.empty());
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    ASSERT_FALSE(src.empty());
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
+    cv::gpu::GpuMat dst;
+    cv::gpu::resize(loadMat(src), dst, cv::Size(), coeff, coeff, interpolation);
 
-        cv::Mat dst_gold;
-        resizeGold(src, dst_gold, coeff, coeff, interpolation);
+    cv::Mat dst_gold;
+    resizeGold(src, dst_gold, coeff, coeff, interpolation);
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 1e-1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ResizeNPP, testing::Combine(
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index 695280de5..cc397404a 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -40,7 +40,7 @@
 //
 //M*/
 
-#include "test_precomp.hpp"
+#include <test_precomp.hpp>
 #include <time.h>
 
 #ifdef HAVE_CUDA
@@ -158,77 +158,62 @@ GPU_TEST_P(SCascadeTestRoi, detect,
         testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
 {
-    try
+    cv::gpu::setDevice(GET_PARAM(0).deviceID());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
+    ASSERT_FALSE(coloredCpu.empty());
+
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+
+    int nroi = GET_PARAM(3);
+    cv::Mat result(coloredCpu);
+    cv::RNG rng;
+    for (int i = 0; i < nroi; ++i)
     {
-        cv::gpu::setDevice(GET_PARAM(0).deviceID());
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
-        ASSERT_FALSE(coloredCpu.empty());
-
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(perf::TestBase::getDataPath(GET_PARAM(1)), cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        GpuMat colored(coloredCpu), objectBoxes(1, 16384, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-
-        int nroi = GET_PARAM(3);
-        cv::Mat result(coloredCpu);
-        cv::RNG rng;
-        for (int i = 0; i < nroi; ++i)
-        {
-            cv::Rect r = getFromTable(rng(10));
-            GpuMat sub(rois, r);
-            sub.setTo(1);
-            cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
-        }
-        objectBoxes.setTo(0);
-
-        cascade.detect(colored, rois, objectBoxes);
-
-        cv::Mat dt(objectBoxes);
-        typedef cv::gpu::SCascade::Detection Detection;
-
-        Detection* dts = ((Detection*)dt.data) + 1;
-        int* count = dt.ptr<int>(0);
-
-        printTotal(std::cout, *count);
-
-        for (int i = 0; i  < *count; ++i)
-        {
-            Detection d = dts[i];
-            print(std::cout, d);
-            cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
-        }
-
-        SHOW(result);
+        cv::Rect r = getFromTable(rng(10));
+        GpuMat sub(rois, r);
+        sub.setTo(1);
+        cv::rectangle(result, r, cv::Scalar(0, 0, 255, 255), 1);
     }
-    catch (...)
+    objectBoxes.setTo(0);
+
+    cascade.detect(colored, rois, objectBoxes);
+
+    cv::Mat dt(objectBoxes);
+    typedef cv::gpu::SCascade::Detection Detection;
+
+    Detection* dts = ((Detection*)dt.data) + 1;
+    int* count = dt.ptr<int>(0);
+
+    printTotal(std::cout, *count);
+
+    for (int i = 0; i  < *count; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        Detection d = dts[i];
+        print(std::cout, d);
+        cv::rectangle(result, cv::Rect(d.x, d.y, d.w, d.h), cv::Scalar(255, 0, 0, 255), 1);
     }
+
+    SHOW(result);
+
 }
 
 TEST(SCascadeTest, readCascade)
 {
-    try
-    {
-        std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
-        cv::gpu::SCascade cascade;
+    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 }
 
 typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
@@ -236,129 +221,105 @@ GPU_TEST_P(SCascadeTestAll, detect,
         ALL_DEVICES
         )
 {
-    try
-    {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-        ASSERT_FALSE(coloredCpu.empty());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
 
-        GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-        sub.setTo(cv::Scalar::all(1));
+    GpuMat colored(coloredCpu), objectBoxes, rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
 
-        objectBoxes.setTo(0);
-        cascade.detect(colored, rois, objectBoxes);
+    objectBoxes.setTo(0);
+    cascade.detect(colored, rois, objectBoxes);
 
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2448);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
         ALL_DEVICES
         )
 {
-    try
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
+
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
+
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+
+    std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
+    cv::FileStorage fsi(intPath, cv::FileStorage::READ);
+    ASSERT_TRUE(fsi.isOpened());
+
+    GpuMat hogluv(121 * 10, 161, CV_32SC1);
+    for (int i = 0; i < 10; ++i)
     {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
-
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
-
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-
-        std::string intPath = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/integrals.xml";
-        cv::FileStorage fsi(intPath, cv::FileStorage::READ);
-        ASSERT_TRUE(fsi.isOpened());
-
-        GpuMat hogluv(121 * 10, 161, CV_32SC1);
-        for (int i = 0; i < 10; ++i)
-        {
-            cv::Mat channel;
-            fsi[std::string("channel") + itoa(i)] >> channel;
-            GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
-            gchannel.upload(channel);
-        }
-
-        GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
-        rois.setTo(1);
-
-        objectBoxes.setTo(0);
-        cascade.detect(hogluv, rois, objectBoxes);
-
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
-
-        ASSERT_EQ(a, 1024);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        cv::Mat channel;
+        fsi[std::string("channel") + itoa(i)] >> channel;
+        GpuMat gchannel(hogluv, cv::Rect(0, 121 * i, 161, 121));
+        gchannel.upload(channel);
     }
+
+    GpuMat objectBoxes(1, 100000, CV_8UC1), rois(cv::Size(640, 480), CV_8UC1);
+    rois.setTo(1);
+
+    objectBoxes.setTo(0);
+    cascade.detect(hogluv, rois, objectBoxes);
+
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+
+    ASSERT_EQ( a ,1024);
 }
 
 GPU_TEST_P(SCascadeTestAll, detectStream,
         ALL_DEVICES
         )
 {
-    try
-    {
-        cv::gpu::setDevice(GetParam().deviceID());
-        std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
-        cv::gpu::SCascade cascade;
+    cv::gpu::setDevice(GetParam().deviceID());
+    std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
+    cv::gpu::SCascade cascade;
 
-        cv::FileStorage fs(xml, cv::FileStorage::READ);
-        ASSERT_TRUE(fs.isOpened());
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
-        ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
 
-        cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
-            + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
-        ASSERT_FALSE(coloredCpu.empty());
+    cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path()
+        + "../cv/cascadeandhog/bahnhof/image_00000000_0.png");
+    ASSERT_FALSE(coloredCpu.empty());
 
-        GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
-        rois.setTo(0);
-        GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
-        sub.setTo(cv::Scalar::all(1));
+    GpuMat colored(coloredCpu), objectBoxes(1, 100000, CV_8UC1), rois(colored.size(), CV_8UC1);
+    rois.setTo(0);
+    GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
+    sub.setTo(cv::Scalar::all(1));
 
-        cv::gpu::Stream s;
+    cv::gpu::Stream s;
 
-        objectBoxes.setTo(0);
-        cascade.detect(colored, rois, objectBoxes, s);
-        s.waitForCompletion();
+    objectBoxes.setTo(0);
+    cascade.detect(colored, rois, objectBoxes, s);
+    s.waitForCompletion();
 
-        typedef cv::gpu::SCascade::Detection Detection;
-        cv::Mat detections(objectBoxes);
-        int a = *(detections.ptr<int>(0));
-        ASSERT_EQ(a, 2448);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    typedef cv::gpu::SCascade::Detection Detection;
+    cv::Mat detections(objectBoxes);
+    int a = *(detections.ptr<int>(0));
+    ASSERT_EQ(a ,2448);
 }
 
 
-#endif
+#endif
\ No newline at end of file
diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp
index 38d92a64d..c56921045 100644
--- a/modules/gpu/test/test_threshold.cpp
+++ b/modules/gpu/test/test_threshold.cpp
@@ -68,25 +68,17 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
 
 TEST_P(Threshold, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        double maxVal = randomDouble(20.0, 127.0);
-        double thresh = randomDouble(0.0, maxVal);
+    cv::Mat src = randomMat(size, type);
+    double maxVal = randomDouble(20.0, 127.0);
+    double thresh = randomDouble(0.0, maxVal);
 
-        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
+    cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::threshold(loadMat(src, useRoi), dst, thresh, maxVal, threshOp);
 
-        cv::Mat dst_gold;
-        cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
+    cv::Mat dst_gold;
+    cv::threshold(src, dst_gold, thresh, maxVal, threshOp);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Threshold, testing::Combine(
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index d1332ce5f..c56e3d2eb 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -65,74 +65,67 @@ struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(BroxOpticalFlow, Regression)
 {
-    try
-    {
-        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                      10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-        cv::gpu::GpuMat u;
-        cv::gpu::GpuMat v;
-        brox(loadMat(frame0), loadMat(frame1), u, v);
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(frame0), loadMat(frame1), u, v);
 
-    #ifndef DUMP
-        std::string fname(cvtest::TS::ptr()->get_data_path());
-        if (devInfo.majorVersion() >= 2)
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-        else
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+#ifndef DUMP
+    std::string fname(cvtest::TS::ptr()->get_data_path());
+    if (devInfo.majorVersion() >= 2)
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+    else
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-        std::ifstream f(fname.c_str(), std::ios_base::binary);
+    std::ifstream f(fname.c_str(), std::ios_base::binary);
 
-        int rows, cols;
+    int rows, cols;
 
-        f.read((char*)&rows, sizeof(rows));
-        f.read((char*)&cols, sizeof(cols));
+    f.read((char*)&rows, sizeof(rows));
+    f.read((char*)&cols, sizeof(cols));
 
-        cv::Mat u_gold(rows, cols, CV_32FC1);
+    cv::Mat u_gold(rows, cols, CV_32FC1);
 
-        for (int i = 0; i < u_gold.rows; ++i)
-            f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
+    for (int i = 0; i < u_gold.rows; ++i)
+        f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
 
-        cv::Mat v_gold(rows, cols, CV_32FC1);
+    cv::Mat v_gold(rows, cols, CV_32FC1);
 
-        for (int i = 0; i < v_gold.rows; ++i)
-            f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
+    for (int i = 0; i < v_gold.rows; ++i)
+        f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
 
-        EXPECT_MAT_NEAR(u_gold, u, 0);
-        EXPECT_MAT_NEAR(v_gold, v, 0);
-    #else
-        std::string fname(cvtest::TS::ptr()->get_data_path());
-        if (devInfo.majorVersion() >= 2)
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-        else
-            fname += BROX_OPTICAL_FLOW_DUMP_FILE;
+    EXPECT_MAT_NEAR(u_gold, u, 0);
+    EXPECT_MAT_NEAR(v_gold, v, 0);
+#else
+    std::string fname(cvtest::TS::ptr()->get_data_path());
+    if (devInfo.majorVersion() >= 2)
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
+    else
+        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
 
-        std::ofstream f(fname.c_str(), std::ios_base::binary);
+    std::ofstream f(fname.c_str(), std::ios_base::binary);
 
-        f.write((char*)&u.rows, sizeof(u.rows));
-        f.write((char*)&u.cols, sizeof(u.cols));
+    f.write((char*)&u.rows, sizeof(u.rows));
+    f.write((char*)&u.cols, sizeof(u.cols));
 
-        cv::Mat h_u(u);
-        cv::Mat h_v(v);
+    cv::Mat h_u(u);
+    cv::Mat h_v(v);
 
-        for (int i = 0; i < u.rows; ++i)
-            f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
+    for (int i = 0; i < u.rows; ++i)
+        f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
 
-        for (int i = 0; i < v.rows; ++i)
-            f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
-    #endif
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    for (int i = 0; i < v.rows; ++i)
+        f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
+
+#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
@@ -158,16 +151,28 @@ PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
 
 TEST_P(GoodFeaturesToTrack, Accuracy)
 {
-    try
+    cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
+
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+
+    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
+    {
+        try
+        {
+            cv::gpu::GpuMat d_pts;
+            detector(loadMat(image), d_pts);
+        }
+        catch (const cv::Exception& e)
+        {
+            ASSERT_EQ(CV_StsNotImplemented, e.code);
+        }
+    }
+    else
     {
-        cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(image.empty());
-
-        int maxCorners = 1000;
-        double qualityLevel = 0.01;
-
-        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
-
         cv::gpu::GpuMat d_pts;
         detector(loadMat(image), d_pts);
 
@@ -196,34 +201,21 @@ TEST_P(GoodFeaturesToTrack, Accuracy)
 
         ASSERT_LE(bad_ratio, 0.01);
     }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
 }
 
 TEST_P(GoodFeaturesToTrack, EmptyCorners)
 {
-    try
-    {
-        int maxCorners = 1000;
-        double qualityLevel = 0.01;
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
 
-        cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
 
-        cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
-        cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
+    cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+    cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
 
-        detector(src, corners);
+    detector(src, corners);
 
-        ASSERT_TRUE( corners.empty() );
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    ASSERT_TRUE( corners.empty() );
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
@@ -251,78 +243,70 @@ PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
 
 TEST_P(PyrLKOpticalFlow, Sparse)
 {
-    try
+    cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Mat gray_frame;
+    if (useGray)
+        gray_frame = frame0;
+    else
+        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
+
+    std::vector<cv::Point2f> pts;
+    cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
+
+    cv::gpu::GpuMat d_pts;
+    cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
+    d_pts.upload(pts_mat);
+
+    cv::gpu::PyrLKOpticalFlow pyrLK;
+
+    cv::gpu::GpuMat d_nextPts;
+    cv::gpu::GpuMat d_status;
+    pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
+
+    std::vector<cv::Point2f> nextPts(d_nextPts.cols);
+    cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
+    d_nextPts.download(nextPts_mat);
+
+    std::vector<unsigned char> status(d_status.cols);
+    cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
+    d_status.download(status_mat);
+
+    std::vector<cv::Point2f> nextPts_gold;
+    std::vector<unsigned char> status_gold;
+    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
+
+    ASSERT_EQ(nextPts_gold.size(), nextPts.size());
+    ASSERT_EQ(status_gold.size(), status.size());
+
+    size_t mistmatch = 0;
+    for (size_t i = 0; i < nextPts.size(); ++i)
     {
-        cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-        ASSERT_FALSE(frame0.empty());
+        cv::Point2i a = nextPts[i];
+        cv::Point2i b = nextPts_gold[i];
 
-        cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-        ASSERT_FALSE(frame1.empty());
-
-        cv::Mat gray_frame;
-        if (useGray)
-            gray_frame = frame0;
-        else
-            cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
-
-        std::vector<cv::Point2f> pts;
-        cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
-
-        cv::gpu::GpuMat d_pts;
-        cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
-        d_pts.upload(pts_mat);
-
-        cv::gpu::PyrLKOpticalFlow pyrLK;
-
-        cv::gpu::GpuMat d_nextPts;
-        cv::gpu::GpuMat d_status;
-        pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
-
-        std::vector<cv::Point2f> nextPts(d_nextPts.cols);
-        cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
-        d_nextPts.download(nextPts_mat);
-
-        std::vector<unsigned char> status(d_status.cols);
-        cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
-        d_status.download(status_mat);
-
-        std::vector<cv::Point2f> nextPts_gold;
-        std::vector<unsigned char> status_gold;
-        cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
-
-        ASSERT_EQ(nextPts_gold.size(), nextPts.size());
-        ASSERT_EQ(status_gold.size(), status.size());
-
-        size_t mistmatch = 0;
-        for (size_t i = 0; i < nextPts.size(); ++i)
+        if (status[i] != status_gold[i])
         {
-            cv::Point2i a = nextPts[i];
-            cv::Point2i b = nextPts_gold[i];
-
-            if (status[i] != status_gold[i])
-            {
-                ++mistmatch;
-                continue;
-            }
-
-            if (status[i])
-            {
-                bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
-
-                if (!eq)
-                    ++mistmatch;
-            }
+            ++mistmatch;
+            continue;
         }
 
-        double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+        if (status[i])
+        {
+            bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
 
-        ASSERT_LE(bad_ratio, 0.01);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+            if (!eq)
+                ++mistmatch;
+        }
     }
+
+    double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+
+    ASSERT_LE(bad_ratio, 0.01);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
@@ -359,53 +343,45 @@ PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, Farn
 
 TEST_P(FarnebackOpticalFlow, Accuracy)
 {
-    try
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    double polySigma = polyN <= 5 ? 1.1 : 1.5;
+
+    cv::gpu::FarnebackOpticalFlow calc;
+    calc.pyrScale = pyrScale;
+    calc.polyN = polyN;
+    calc.polySigma = polySigma;
+    calc.flags = flags;
+
+    cv::gpu::GpuMat d_flowx, d_flowy;
+    calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+
+    cv::Mat flow;
+    if (useInitFlow)
     {
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+        cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
+        cv::merge(flowxy, 2, flow);
+    }
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
-
-        double polySigma = polyN <= 5 ? 1.1 : 1.5;
-
-        cv::gpu::FarnebackOpticalFlow calc;
-        calc.pyrScale = pyrScale;
-        calc.polyN = polyN;
-        calc.polySigma = polySigma;
-        calc.flags = flags;
-
-        cv::gpu::GpuMat d_flowx, d_flowy;
+    if (useInitFlow)
+    {
+        calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
         calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-
-        cv::Mat flow;
-        if (useInitFlow)
-        {
-            cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
-            cv::merge(flowxy, 2, flow);
-        }
-
-        if (useInitFlow)
-        {
-            calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
-            calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-        }
-
-        cv::calcOpticalFlowFarneback(
-            frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
-            calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
-
-        std::vector<cv::Mat> flowxy;
-        cv::split(flow, flowxy);
-
-        EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
-        EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
     }
+
+    cv::calcOpticalFlowFarneback(
+        frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
+        calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
+
+    std::vector<cv::Mat> flowxy;
+    cv::split(flow, flowxy);
+
+    EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
+    EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
@@ -419,35 +395,27 @@ struct OpticalFlowNan : public BroxOpticalFlow {};
 
 TEST_P(OpticalFlowNan, Regression)
 {
-    try
-    {
-        cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-        ASSERT_FALSE(frame0.empty());
-        cv::Mat r_frame0, r_frame1;
-        cv::resize(frame0, r_frame0, cv::Size(1380,1000));
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
+    cv::Mat r_frame0, r_frame1;
+    cv::resize(frame0, r_frame0, cv::Size(1380,1000));
 
-        cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-        ASSERT_FALSE(frame1.empty());
-        cv::resize(frame1, r_frame1, cv::Size(1380,1000));
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
+    cv::resize(frame1, r_frame1, cv::Size(1380,1000));
 
-        cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                      5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
 
-        cv::gpu::GpuMat u;
-        cv::gpu::GpuMat v;
-        brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
 
-        cv::Mat h_u, h_v;
-        u.download(h_u);
-        v.download(h_v);
-        EXPECT_TRUE(cv::checkRange(h_u));
-        EXPECT_TRUE(cv::checkRange(h_v));
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    cv::Mat h_u, h_v;
+    u.download(h_u);
+    v.download(h_v);
+    EXPECT_TRUE(cv::checkRange(h_u));
+    EXPECT_TRUE(cv::checkRange(h_v));
 };
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
@@ -461,38 +429,30 @@ PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
 
 TEST_P(OpticalFlowDual_TVL1, Accuracy)
 {
-    try
-    {
-        cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        const bool useRoi = GET_PARAM(1);
+    const bool useRoi = GET_PARAM(1);
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-        cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
-        cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
-        d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
 
-        cv::OpticalFlowDual_TVL1 alg;
-        cv::Mat flow;
-        alg(frame0, frame1, flow);
-        cv::Mat gold[2];
-        cv::split(flow, gold);
+    cv::OpticalFlowDual_TVL1 alg;
+    cv::Mat flow;
+    alg(frame0, frame1, flow);
+    cv::Mat gold[2];
+    cv::split(flow, gold);
 
-        EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
-        EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
@@ -526,37 +486,29 @@ struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(OpticalFlowBM, Accuracy)
 {
-    try
-    {
-        cv::gpu::DeviceInfo devInfo = GetParam();
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::Size block_size(16, 16);
-        cv::Size shift_size(1, 1);
-        cv::Size max_range(16, 16);
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
 
-        cv::gpu::GpuMat d_velx, d_vely, buf;
-        cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
-                                   block_size, shift_size, max_range, false,
-                                   d_velx, d_vely, buf);
+    cv::gpu::GpuMat d_velx, d_vely, buf;
+    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+                               block_size, shift_size, max_range, false,
+                               d_velx, d_vely, buf);
 
-        cv::Mat velx, vely;
-        calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+    cv::Mat velx, vely;
+    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
 
-        EXPECT_MAT_NEAR(velx, d_velx, 0);
-        EXPECT_MAT_NEAR(vely, d_vely, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(velx, d_velx, 0);
+    EXPECT_MAT_NEAR(vely, d_vely, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
@@ -634,52 +586,44 @@ struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
 
 TEST_P(FastOpticalFlowBM, Accuracy)
 {
-    try
-    {
-        const double MAX_RMSE = 0.6;
+    const double MAX_RMSE = 0.6;
 
-        int search_window = 15;
-        int block_window = 5;
+    int search_window = 15;
+    int block_window = 5;
 
-        cv::gpu::DeviceInfo devInfo = GetParam();
-        cv::gpu::setDevice(devInfo.deviceID());
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
 
-        cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame0.empty());
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
 
-        cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-        ASSERT_FALSE(frame1.empty());
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
 
-        cv::Size smallSize(320, 240);
-        cv::Mat frame0_small;
-        cv::Mat frame1_small;
+    cv::Size smallSize(320, 240);
+    cv::Mat frame0_small;
+    cv::Mat frame1_small;
 
-        cv::resize(frame0, frame0_small, smallSize);
-        cv::resize(frame1, frame1_small, smallSize);
+    cv::resize(frame0, frame0_small, smallSize);
+    cv::resize(frame1, frame1_small, smallSize);
 
-        cv::gpu::GpuMat d_flowx;
-        cv::gpu::GpuMat d_flowy;
-        cv::gpu::FastOpticalFlowBM fastBM;
+    cv::gpu::GpuMat d_flowx;
+    cv::gpu::GpuMat d_flowy;
+    cv::gpu::FastOpticalFlowBM fastBM;
 
-        fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
 
-        cv::Mat_<float> flowx;
-        cv::Mat_<float> flowy;
-        FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+    cv::Mat_<float> flowx;
+    cv::Mat_<float> flowy;
+    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
 
-        double err;
+    double err;
 
-        err = calc_rmse(flowx, cv::Mat(d_flowx));
-        EXPECT_LE(err, MAX_RMSE);
+    err = calc_rmse(flowx, cv::Mat(d_flowx));
+    EXPECT_LE(err, MAX_RMSE);
 
-        err = calc_rmse(flowy, cv::Mat(d_flowy));
-        EXPECT_LE(err, MAX_RMSE);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    err = calc_rmse(flowy, cv::Mat(d_flowy));
+    EXPECT_LE(err, MAX_RMSE);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
@@ -714,63 +658,55 @@ PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
 
 TEST_P(FGDStatModel, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    IplImage ipl_frame = frame;
+    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+
+    cv::gpu::GpuMat d_frame(frame);
+    cv::gpu::FGDStatModel d_model(out_cn);
+    d_model.create(d_frame);
+
+    cv::Mat h_background;
+    cv::Mat h_foreground;
+    cv::Mat h_background3;
+
+    cv::Mat backgroundDiff;
+    cv::Mat foregroundDiff;
+
+    for (int i = 0; i < 5; ++i)
+    {
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        IplImage ipl_frame = frame;
-        cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+        ipl_frame = frame;
+        int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
 
-        cv::gpu::GpuMat d_frame(frame);
-        cv::gpu::FGDStatModel d_model(out_cn);
-        d_model.create(d_frame);
+        d_frame.upload(frame);
 
-        cv::Mat h_background;
-        cv::Mat h_foreground;
-        cv::Mat h_background3;
+        int count = d_model.update(d_frame);
 
-        cv::Mat backgroundDiff;
-        cv::Mat foregroundDiff;
+        ASSERT_EQ(gold_count, count);
 
-        for (int i = 0; i < 5; ++i)
+        cv::Mat gold_background(model->background);
+        cv::Mat gold_foreground(model->foreground);
+
+        if (out_cn == 3)
+            d_model.background.download(h_background3);
+        else
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            ipl_frame = frame;
-            int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
-
-            d_frame.upload(frame);
-
-            int count = d_model.update(d_frame);
-
-            ASSERT_EQ(gold_count, count);
-
-            cv::Mat gold_background(model->background);
-            cv::Mat gold_foreground(model->foreground);
-
-            if (out_cn == 3)
-                d_model.background.download(h_background3);
-            else
-            {
-                d_model.background.download(h_background);
-                cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
-            }
-            d_model.foreground.download(h_foreground);
-
-            ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
-            ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+            d_model.background.download(h_background);
+            cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        d_model.foreground.download(h_foreground);
+
+        ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
+        ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
     }
 }
 
@@ -809,44 +745,36 @@ PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, Us
 
 TEST_P(MOG, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    cv::gpu::MOG_GPU mog;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+    cv::BackgroundSubtractorMOG mog_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
+    {
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        cv::gpu::MOG_GPU mog;
-        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-        cv::BackgroundSubtractorMOG mog_gold;
-        cv::Mat foreground_gold;
-
-        for (int i = 0; i < 10; ++i)
+        if (useGray)
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            if (useGray)
-            {
-                cv::Mat temp;
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                cv::swap(temp, frame);
-            }
-
-            mog(loadMat(frame, useRoi), foreground, (float)learningRate);
-
-            mog_gold(frame, foreground_gold, learningRate);
-
-            ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
+
+        mog_gold(frame, foreground_gold, learningRate);
+
+        ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
     }
 }
 
@@ -882,48 +810,40 @@ PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
 
 TEST_P(MOG2, Update)
 {
-    try
-    {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
 
-        cv::Mat frame;
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
+    {
         cap >> frame;
         ASSERT_FALSE(frame.empty());
 
-        cv::gpu::MOG2_GPU mog2;
-        cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-        cv::BackgroundSubtractorMOG2 mog2_gold;
-        cv::Mat foreground_gold;
-
-        for (int i = 0; i < 10; ++i)
+        if (useGray)
         {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            if (useGray)
-            {
-                cv::Mat temp;
-                cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-                cv::swap(temp, frame);
-            }
-
-            mog2(loadMat(frame, useRoi), foreground);
-
-            mog2_gold(frame, foreground_gold);
-
-            double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
-
-            norm /= foreground_gold.size().area();
-
-            ASSERT_LE(norm, 0.09);
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
         }
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+
+        mog2(loadMat(frame, useRoi), foreground);
+
+        mog2_gold(frame, foreground_gold);
+
+        double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
+
+        norm /= foreground_gold.size().area();
+
+        ASSERT_LE(norm, 0.09);
     }
 }
 
@@ -932,42 +852,34 @@ TEST_P(MOG2, getBackgroundImage)
     if (useGray)
         return;
 
-    try
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
+
+    cv::Mat frame;
+
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground;
+
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
     {
-        cv::VideoCapture cap(inputFile);
-        ASSERT_TRUE(cap.isOpened());
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
 
-        cv::Mat frame;
+        mog2(loadMat(frame, useRoi), foreground);
 
-        cv::gpu::MOG2_GPU mog2;
-        cv::gpu::GpuMat foreground;
-
-        cv::BackgroundSubtractorMOG2 mog2_gold;
-        cv::Mat foreground_gold;
-
-        for (int i = 0; i < 10; ++i)
-        {
-            cap >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            mog2(loadMat(frame, useRoi), foreground);
-
-            mog2_gold(frame, foreground_gold);
-        }
-
-        cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
-        mog2.getBackgroundImage(background);
-
-        cv::Mat background_gold;
-        mog2_gold.getBackgroundImage(background_gold);
-
-        ASSERT_MAT_NEAR(background_gold, background, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        mog2_gold(frame, foreground_gold);
     }
+
+    cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
+    mog2.getBackgroundImage(background);
+
+    cv::Mat background_gold;
+    mog2_gold.getBackgroundImage(background_gold);
+
+    ASSERT_MAT_NEAR(background_gold, background, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
@@ -985,38 +897,30 @@ PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
 
 TEST_P(VIBE, Accuracy)
 {
-    try
-    {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const int type = GET_PARAM(2);
-        const bool useRoi = GET_PARAM(3);
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int type = GET_PARAM(2);
+    const bool useRoi = GET_PARAM(3);
 
-        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
 
-        cv::Mat frame = randomMat(size, type, 0.0, 100);
-        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+    cv::Mat frame = randomMat(size, type, 0.0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
 
-        cv::gpu::VIBE_GPU vibe;
-        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-        vibe.initialize(d_frame);
+    cv::gpu::VIBE_GPU vibe;
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+    vibe.initialize(d_frame);
 
-        for (int i = 0; i < 20; ++i)
-            vibe(d_frame, d_fgmask);
-
-        frame = randomMat(size, type, 160, 255);
-        d_frame = loadMat(frame, useRoi);
+    for (int i = 0; i < 20; ++i)
         vibe(d_frame, d_fgmask);
 
-        // now fgmask should be entirely foreground
-        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    vibe(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
@@ -1034,50 +938,42 @@ PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
 
 TEST_P(GMG, Accuracy)
 {
-    try
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int depth = GET_PARAM(2);
+    const int channels = GET_PARAM(3);
+    const bool useRoi = GET_PARAM(4);
+
+    const int type = CV_MAKE_TYPE(depth, channels);
+
+    const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat frame = randomMat(size, type, 0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+
+    cv::gpu::GMG_GPU gmg;
+    gmg.numInitializationFrames = 5;
+    gmg.smoothingRadius = 0;
+    gmg.initialize(d_frame.size(), 0, 255);
+
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+
+    for (int i = 0; i < gmg.numInitializationFrames; ++i)
     {
-        const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-        const cv::Size size = GET_PARAM(1);
-        const int depth = GET_PARAM(2);
-        const int channels = GET_PARAM(3);
-        const bool useRoi = GET_PARAM(4);
-
-        const int type = CV_MAKE_TYPE(depth, channels);
-
-        const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
-        const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
-
-        cv::Mat frame = randomMat(size, type, 0, 100);
-        cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
-
-        cv::gpu::GMG_GPU gmg;
-        gmg.numInitializationFrames = 5;
-        gmg.smoothingRadius = 0;
-        gmg.initialize(d_frame.size(), 0, 255);
-
-        cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-
-        for (int i = 0; i < gmg.numInitializationFrames; ++i)
-        {
-            gmg(d_frame, d_fgmask);
-
-            // fgmask should be entirely background during training
-            ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
-        }
-
-        frame = randomMat(size, type, 160, 255);
-        d_frame = loadMat(frame, useRoi);
         gmg(d_frame, d_fgmask);
 
-        // now fgmask should be entirely foreground
-        ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        // fgmask should be entirely background during training
+        ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
     }
+
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    gmg(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
@@ -1113,47 +1009,39 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoWriter, Regression)
 {
-    try
+    const double FPS = 25.0;
+
+    cv::VideoCapture reader(inputFile);
+    ASSERT_TRUE( reader.isOpened() );
+
+    cv::gpu::VideoWriter_GPU d_writer;
+
+    cv::Mat frame;
+    cv::gpu::GpuMat d_frame;
+
+    for (int i = 0; i < 10; ++i)
     {
-        const double FPS = 25.0;
+        reader >> frame;
+        ASSERT_FALSE(frame.empty());
 
-        cv::VideoCapture reader(inputFile);
-        ASSERT_TRUE( reader.isOpened() );
+        d_frame.upload(frame);
 
-        cv::gpu::VideoWriter_GPU d_writer;
+        if (!d_writer.isOpened())
+            d_writer.open(outputFile, frame.size(), FPS);
 
-        cv::Mat frame;
-        cv::gpu::GpuMat d_frame;
-
-        for (int i = 0; i < 10; ++i)
-        {
-            reader >> frame;
-            ASSERT_FALSE(frame.empty());
-
-            d_frame.upload(frame);
-
-            if (!d_writer.isOpened())
-                d_writer.open(outputFile, frame.size(), FPS);
-
-            d_writer.write(d_frame);
-        }
-
-        reader.release();
-        d_writer.close();
-
-        reader.open(outputFile);
-        ASSERT_TRUE( reader.isOpened() );
-
-        for (int i = 0; i < 5; ++i)
-        {
-            reader >> frame;
-            ASSERT_FALSE( frame.empty() );
-        }
+        d_writer.write(d_frame);
     }
-    catch (...)
+
+    reader.release();
+    d_writer.close();
+
+    reader.open(outputFile);
+    ASSERT_TRUE( reader.isOpened() );
+
+    for (int i = 0; i < 5; ++i)
     {
-        cv::gpu::resetDevice();
-        throw;
+        reader >> frame;
+        ASSERT_FALSE( frame.empty() );
     }
 }
 
@@ -1182,27 +1070,19 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
 
 TEST_P(VideoReader, Regression)
 {
-    try
+    cv::gpu::VideoReader_GPU reader(inputFile);
+    ASSERT_TRUE( reader.isOpened() );
+
+    cv::gpu::GpuMat frame;
+
+    for (int i = 0; i < 10; ++i)
     {
-        cv::gpu::VideoReader_GPU reader(inputFile);
-        ASSERT_TRUE( reader.isOpened() );
-
-        cv::gpu::GpuMat frame;
-
-        for (int i = 0; i < 10; ++i)
-        {
-            ASSERT_TRUE( reader.read(frame) );
-            ASSERT_FALSE( frame.empty() );
-        }
-
-        reader.close();
-        ASSERT_FALSE( reader.isOpened() );
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
+        ASSERT_TRUE( reader.read(frame) );
+        ASSERT_FALSE( frame.empty() );
     }
+
+    reader.close();
+    ASSERT_FALSE( reader.isOpened() );
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp
index 256f7504a..065c6755e 100644
--- a/modules/gpu/test/test_warp_affine.cpp
+++ b/modules/gpu/test/test_warp_affine.cpp
@@ -76,32 +76,24 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
 
 TEST_P(BuildWarpAffineMaps, Accuracy)
 {
-    try
-    {
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-        cv::gpu::GpuMat xmap, ymap;
-        cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+    cv::gpu::GpuMat xmap, ymap;
+    cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
 
-        int interpolation = cv::INTER_NEAREST;
-        int borderMode = cv::BORDER_CONSTANT;
+    int interpolation = cv::INTER_NEAREST;
+    int borderMode = cv::BORDER_CONSTANT;
 
-        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-        cv::Mat dst;
-        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
 
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Mat dst_gold;
-        cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat dst_gold;
+    cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpAffineMaps, testing::Combine(
@@ -209,28 +201,20 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
 
 TEST_P(WarpAffine, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::warpAffine(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-        cv::Mat dst_gold;
-        warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    warpAffineGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffine, testing::Combine(
@@ -265,27 +249,19 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
 
 TEST_P(WarpAffineNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
+    cv::gpu::GpuMat dst;
+    cv::gpu::warpAffine(loadMat(src), dst, M, src.size(), flags);
 
-        cv::Mat dst_gold;
-        warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+    cv::Mat dst_gold;
+    warpAffineGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpAffineNPP, testing::Combine(
diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp
index 77e88d43d..95c089bb9 100644
--- a/modules/gpu/test/test_warp_perspective.cpp
+++ b/modules/gpu/test/test_warp_perspective.cpp
@@ -77,29 +77,21 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
 
 TEST_P(BuildWarpPerspectiveMaps, Accuracy)
 {
-    try
-    {
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
-        cv::gpu::GpuMat xmap, ymap;
-        cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+    cv::gpu::GpuMat xmap, ymap;
+    cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
 
-        cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-        cv::Mat dst;
-        cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
+    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
 
-        int flags = cv::INTER_NEAREST;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Mat dst_gold;
-        cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
+    int flags = cv::INTER_NEAREST;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat dst_gold;
+    cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, BuildWarpPerspectiveMaps, testing::Combine(
@@ -209,28 +201,20 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
 
 TEST_P(WarpPerspective, Accuracy)
 {
-    try
-    {
-        cv::Mat src = randomMat(size, type);
-        cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
-        cv::Scalar val = randomScalar(0.0, 255.0);
+    cv::Mat src = randomMat(size, type);
+    cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
+    cv::Scalar val = randomScalar(0.0, 255.0);
 
-        cv::gpu::GpuMat dst = createMat(size, type, useRoi);
-        cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
+    cv::gpu::GpuMat dst = createMat(size, type, useRoi);
+    cv::gpu::warpPerspective(loadMat(src, useRoi), dst, M, size, flags, borderType, val);
 
-        cv::Mat dst_gold;
-        warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
+    cv::Mat dst_gold;
+    warpPerspectiveGold(src, M, inverse, size, dst_gold, interpolation, borderType, val);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, src.depth() == CV_32F ? 1e-1 : 1.0);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspective, testing::Combine(
@@ -265,27 +249,19 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
 
 TEST_P(WarpPerspectiveNPP, Accuracy)
 {
-    try
-    {
-        cv::Mat src = readImageType("stereobp/aloe-L.png", type);
-        cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
-        int flags = interpolation;
-        if (inverse)
-            flags |= cv::WARP_INVERSE_MAP;
+    cv::Mat src = readImageType("stereobp/aloe-L.png", type);
+    cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
+    int flags = interpolation;
+    if (inverse)
+        flags |= cv::WARP_INVERSE_MAP;
 
-        cv::gpu::GpuMat dst;
-        cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
+    cv::gpu::GpuMat dst;
+    cv::gpu::warpPerspective(loadMat(src), dst, M, src.size(), flags);
 
-        cv::Mat dst_gold;
-        warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
+    cv::Mat dst_gold;
+    warpPerspectiveGold(src, M, inverse, src.size(), dst_gold, interpolation, cv::BORDER_CONSTANT, cv::Scalar::all(0));
 
-        EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
-    }
-    catch (...)
-    {
-        cv::gpu::resetDevice();
-        throw;
-    }
+    EXPECT_MAT_SIMILAR(dst_gold, dst, 2e-2);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_ImgProc, WarpPerspectiveNPP, testing::Combine(

From 1a76242d9949acff9e63f323ef4e1b843590ba33 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 19 Dec 2012 12:32:40 +0400
Subject: [PATCH 150/155] added GPU_TEST_P macros

---
 modules/gpu/test/nvidia/main_nvidia.cpp    |   6 +-
 modules/gpu/test/test_bgfg.cpp             | 405 +++++++++
 modules/gpu/test/test_calib3d.cpp          |  18 +-
 modules/gpu/test/test_color.cpp            | 332 +++----
 modules/gpu/test/test_copy_make_border.cpp |  11 +-
 modules/gpu/test/test_core.cpp             | 547 ++++++------
 modules/gpu/test/test_denoising.cpp        |  13 +-
 modules/gpu/test/test_features2d.cpp       | 249 +++---
 modules/gpu/test/test_filters.cpp          |  56 +-
 modules/gpu/test/test_global_motion.cpp    |   2 +-
 modules/gpu/test/test_gpumat.cpp           |  22 +-
 modules/gpu/test/test_hough.cpp            |  12 +-
 modules/gpu/test/test_imgproc.cpp          | 299 ++++---
 modules/gpu/test/test_labeling.cpp         |   8 +-
 modules/gpu/test/test_nvidia.cpp           |  36 +-
 modules/gpu/test/test_objdetect.cpp        |  15 +-
 modules/gpu/test/test_opengl.cpp           |  60 +-
 modules/gpu/test/test_optflow.cpp          | 623 +++++++++++++
 modules/gpu/test/test_precomp.hpp          |   1 +
 modules/gpu/test/test_pyramids.cpp         |   4 +-
 modules/gpu/test/test_remap.cpp            |   2 +-
 modules/gpu/test/test_resize.cpp           |   8 +-
 modules/gpu/test/test_softcascade.cpp      | 113 ++-
 modules/gpu/test/test_threshold.cpp        |   2 +-
 modules/gpu/test/test_video.cpp            | 964 +--------------------
 modules/gpu/test/test_warp_affine.cpp      |  18 +-
 modules/gpu/test/test_warp_perspective.cpp |  21 +-
 modules/gpu/test/utility.cpp               | 117 ++-
 modules/gpu/test/utility.hpp               |  72 +-
 29 files changed, 2049 insertions(+), 1987 deletions(-)
 create mode 100644 modules/gpu/test/test_bgfg.cpp
 create mode 100644 modules/gpu/test/test_optflow.cpp

diff --git a/modules/gpu/test/nvidia/main_nvidia.cpp b/modules/gpu/test/nvidia/main_nvidia.cpp
index 7873563ce..43c92ce1e 100644
--- a/modules/gpu/test/nvidia/main_nvidia.cpp
+++ b/modules/gpu/test/nvidia/main_nvidia.cpp
@@ -276,6 +276,8 @@ static void devNullOutput(const std::string& msg)
     (void)msg;
 }
 
+}
+
 bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path.c_str();
@@ -292,8 +294,6 @@ bool nvidia_NPPST_Integral_Image(const std::string& test_data_path, OutputLevel
     return testListerII.invoke();
 }
 
-}
-
 bool nvidia_NPPST_Squared_Integral_Image(const std::string& test_data_path, OutputLevel outputLevel)
 {
     path = test_data_path;
@@ -439,4 +439,4 @@ bool nvidia_NCV_Visualization(const std::string& test_data_path, OutputLevel out
     return testListerVisualize.invoke();
 }
 
-#endif /* CUDA_DISABLER */
\ No newline at end of file
+#endif /* CUDA_DISABLER */
diff --git a/modules/gpu/test/test_bgfg.cpp b/modules/gpu/test/test_bgfg.cpp
new file mode 100644
index 000000000..bac835ef1
--- /dev/null
+++ b/modules/gpu/test/test_bgfg.cpp
@@ -0,0 +1,405 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+//////////////////////////////////////////////////////
+// FGDStatModel
+
+namespace cv
+{
+    template<> void Ptr<CvBGStatModel>::delete_obj()
+    {
+        cvReleaseBGStatModel(&obj);
+    }
+}
+
+PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
+{
+    cv::gpu::DeviceInfo devInfo;
+    std::string inputFile;
+    int out_cn;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
+
+        out_cn = GET_PARAM(2);
+    }
+};
+
+GPU_TEST_P(FGDStatModel, Update)
+{
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
+
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    IplImage ipl_frame = frame;
+    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
+
+    cv::gpu::GpuMat d_frame(frame);
+    cv::gpu::FGDStatModel d_model(out_cn);
+    d_model.create(d_frame);
+
+    cv::Mat h_background;
+    cv::Mat h_foreground;
+    cv::Mat h_background3;
+
+    cv::Mat backgroundDiff;
+    cv::Mat foregroundDiff;
+
+    for (int i = 0; i < 5; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
+
+        ipl_frame = frame;
+        int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
+
+        d_frame.upload(frame);
+
+        int count = d_model.update(d_frame);
+
+        ASSERT_EQ(gold_count, count);
+
+        cv::Mat gold_background(model->background);
+        cv::Mat gold_foreground(model->foreground);
+
+        if (out_cn == 3)
+            d_model.background.download(h_background3);
+        else
+        {
+            d_model.background.download(h_background);
+            cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
+        }
+        d_model.foreground.download(h_foreground);
+
+        ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
+        ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, FGDStatModel, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(std::string("768x576.avi")),
+    testing::Values(Channels(3), Channels(4))));
+
+//////////////////////////////////////////////////////
+// MOG
+
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(UseGray, bool)
+    IMPLEMENT_PARAM_CLASS(LearningRate, double)
+}
+
+PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    std::string inputFile;
+    bool useGray;
+    double learningRate;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
+
+        useGray = GET_PARAM(2);
+
+        learningRate = GET_PARAM(3);
+
+        useRoi = GET_PARAM(4);
+    }
+};
+
+GPU_TEST_P(MOG, Update)
+{
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
+
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    cv::gpu::MOG_GPU mog;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+    cv::BackgroundSubtractorMOG mog_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
+
+        if (useGray)
+        {
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
+        }
+
+        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
+
+        mog_gold(frame, foreground_gold, learningRate);
+
+        ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, MOG, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(std::string("768x576.avi")),
+    testing::Values(UseGray(true), UseGray(false)),
+    testing::Values(LearningRate(0.0), LearningRate(0.01)),
+    WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////
+// MOG2
+
+PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    std::string inputFile;
+    bool useGray;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
+
+        useGray = GET_PARAM(2);
+
+        useRoi = GET_PARAM(3);
+    }
+};
+
+GPU_TEST_P(MOG2, Update)
+{
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
+
+    cv::Mat frame;
+    cap >> frame;
+    ASSERT_FALSE(frame.empty());
+
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
+
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
+
+        if (useGray)
+        {
+            cv::Mat temp;
+            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
+            cv::swap(temp, frame);
+        }
+
+        mog2(loadMat(frame, useRoi), foreground);
+
+        mog2_gold(frame, foreground_gold);
+
+        double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
+
+        norm /= foreground_gold.size().area();
+
+        ASSERT_LE(norm, 0.09);
+    }
+}
+
+GPU_TEST_P(MOG2, getBackgroundImage)
+{
+    if (useGray)
+        return;
+
+    cv::VideoCapture cap(inputFile);
+    ASSERT_TRUE(cap.isOpened());
+
+    cv::Mat frame;
+
+    cv::gpu::MOG2_GPU mog2;
+    cv::gpu::GpuMat foreground;
+
+    cv::BackgroundSubtractorMOG2 mog2_gold;
+    cv::Mat foreground_gold;
+
+    for (int i = 0; i < 10; ++i)
+    {
+        cap >> frame;
+        ASSERT_FALSE(frame.empty());
+
+        mog2(loadMat(frame, useRoi), foreground);
+
+        mog2_gold(frame, foreground_gold);
+    }
+
+    cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
+    mog2.getBackgroundImage(background);
+
+    cv::Mat background_gold;
+    mog2_gold.getBackgroundImage(background_gold);
+
+    ASSERT_MAT_NEAR(background_gold, background, 0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(std::string("768x576.avi")),
+    testing::Values(UseGray(true), UseGray(false)),
+    WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////
+// VIBE
+
+PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
+{
+};
+
+GPU_TEST_P(VIBE, Accuracy)
+{
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int type = GET_PARAM(2);
+    const bool useRoi = GET_PARAM(3);
+
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat frame = randomMat(size, type, 0.0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+
+    cv::gpu::VIBE_GPU vibe;
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+    vibe.initialize(d_frame);
+
+    for (int i = 0; i < 20; ++i)
+        vibe(d_frame, d_fgmask);
+
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    vibe(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4)),
+    WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////
+// GMG
+
+PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
+{
+};
+
+GPU_TEST_P(GMG, Accuracy)
+{
+    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
+    cv::gpu::setDevice(devInfo.deviceID());
+    const cv::Size size = GET_PARAM(1);
+    const int depth = GET_PARAM(2);
+    const int channels = GET_PARAM(3);
+    const bool useRoi = GET_PARAM(4);
+
+    const int type = CV_MAKE_TYPE(depth, channels);
+
+    const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
+    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
+
+    cv::Mat frame = randomMat(size, type, 0, 100);
+    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
+
+    cv::gpu::GMG_GPU gmg;
+    gmg.numInitializationFrames = 5;
+    gmg.smoothingRadius = 0;
+    gmg.initialize(d_frame.size(), 0, 255);
+
+    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
+
+    for (int i = 0; i < gmg.numInitializationFrames; ++i)
+    {
+        gmg(d_frame, d_fgmask);
+
+        // fgmask should be entirely background during training
+        ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
+    }
+
+    frame = randomMat(size, type, 160, 255);
+    d_frame = loadMat(frame, useRoi);
+    gmg(d_frame, d_fgmask);
+
+    // now fgmask should be entirely foreground
+    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
+    ALL_DEVICES,
+    DIFFERENT_SIZES,
+    testing::Values(MatType(CV_8U), MatType(CV_16U), MatType(CV_32F)),
+    testing::Values(Channels(1), Channels(3), Channels(4)),
+    WHOLE_SUBMAT));
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_calib3d.cpp b/modules/gpu/test/test_calib3d.cpp
index a294a3df9..318de8d89 100644
--- a/modules/gpu/test/test_calib3d.cpp
+++ b/modules/gpu/test/test_calib3d.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 //////////////////////////////////////////////////////////////////////////
 // StereoBM
 
@@ -60,7 +58,7 @@ struct StereoBM : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(StereoBM, Regression)
+GPU_TEST_P(StereoBM, Regression)
 {
     cv::Mat left_image  = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
     cv::Mat right_image = readImage("stereobm/aloe-R.png", cv::IMREAD_GRAYSCALE);
@@ -95,7 +93,7 @@ struct StereoBeliefPropagation : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(StereoBeliefPropagation, Regression)
+GPU_TEST_P(StereoBeliefPropagation, Regression)
 {
     cv::Mat left_image  = readImage("stereobp/aloe-L.png");
     cv::Mat right_image = readImage("stereobp/aloe-R.png");
@@ -133,7 +131,7 @@ struct StereoConstantSpaceBP : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(StereoConstantSpaceBP, Regression)
+GPU_TEST_P(StereoConstantSpaceBP, Regression)
 {
     cv::Mat left_image  = readImage("csstereobp/aloe-L.png");
     cv::Mat right_image = readImage("csstereobp/aloe-R.png");
@@ -177,7 +175,7 @@ struct TransformPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(TransformPoints, Accuracy)
+GPU_TEST_P(TransformPoints, Accuracy)
 {
     cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
     cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -225,7 +223,7 @@ struct ProjectPoints : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(ProjectPoints, Accuracy)
+GPU_TEST_P(ProjectPoints, Accuracy)
 {
     cv::Mat src = randomMat(cv::Size(1000, 1), CV_32FC3, 0, 10);
     cv::Mat rvec = randomMat(cv::Size(3, 1), CV_32F, 0, 1);
@@ -275,7 +273,7 @@ struct SolvePnPRansac : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(SolvePnPRansac, Accuracy)
+GPU_TEST_P(SolvePnPRansac, Accuracy)
 {
     cv::Mat object = randomMat(cv::Size(5000, 1), CV_32FC3, 0, 100);
     cv::Mat camera_mat = randomMat(cv::Size(3, 3), CV_32F, 0.5, 1);
@@ -324,7 +322,7 @@ PARAM_TEST_CASE(ReprojectImageTo3D, cv::gpu::DeviceInfo, cv::Size, MatDepth, Use
     }
 };
 
-TEST_P(ReprojectImageTo3D, Accuracy)
+GPU_TEST_P(ReprojectImageTo3D, Accuracy)
 {
     cv::Mat disp = randomMat(size, depth, 5.0, 30.0);
     cv::Mat Q = randomMat(cv::Size(4, 4), CV_32FC1, 0.1, 1.0);
@@ -344,6 +342,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Calib3D, ReprojectImageTo3D, testing::Combine(
     testing::Values(MatDepth(CV_8U), MatDepth(CV_16S)),
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_color.cpp b/modules/gpu/test/test_color.cpp
index 2510f564d..e30dcfdba 100644
--- a/modules/gpu/test/test_color.cpp
+++ b/modules/gpu/test/test_color.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // cvtColor
 
@@ -70,7 +68,7 @@ PARAM_TEST_CASE(CvtColor, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(CvtColor, BGR2RGB)
+GPU_TEST_P(CvtColor, BGR2RGB)
 {
     cv::Mat src = img;
 
@@ -83,7 +81,7 @@ TEST_P(CvtColor, BGR2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR2RGBA)
+GPU_TEST_P(CvtColor, BGR2RGBA)
 {
     cv::Mat src = img;
 
@@ -96,7 +94,7 @@ TEST_P(CvtColor, BGR2RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR2BGRA)
+GPU_TEST_P(CvtColor, BGR2BGRA)
 {
     cv::Mat src = img;
 
@@ -109,7 +107,7 @@ TEST_P(CvtColor, BGR2BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2RGB)
+GPU_TEST_P(CvtColor, BGRA2RGB)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
@@ -123,7 +121,7 @@ TEST_P(CvtColor, BGRA2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2BGR)
+GPU_TEST_P(CvtColor, BGRA2BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
@@ -137,7 +135,7 @@ TEST_P(CvtColor, BGRA2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2RGBA)
+GPU_TEST_P(CvtColor, BGRA2RGBA)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
@@ -151,7 +149,7 @@ TEST_P(CvtColor, BGRA2RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR2GRAY)
+GPU_TEST_P(CvtColor, BGR2GRAY)
 {
     cv::Mat src = img;
 
@@ -164,7 +162,7 @@ TEST_P(CvtColor, BGR2GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGB2GRAY)
+GPU_TEST_P(CvtColor, RGB2GRAY)
 {
     cv::Mat src = img;
 
@@ -177,7 +175,7 @@ TEST_P(CvtColor, RGB2GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, GRAY2BGR)
+GPU_TEST_P(CvtColor, GRAY2BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
@@ -191,7 +189,7 @@ TEST_P(CvtColor, GRAY2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, GRAY2BGRA)
+GPU_TEST_P(CvtColor, GRAY2BGRA)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2GRAY);
@@ -205,7 +203,7 @@ TEST_P(CvtColor, GRAY2BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2GRAY)
+GPU_TEST_P(CvtColor, BGRA2GRAY)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
@@ -219,7 +217,7 @@ TEST_P(CvtColor, BGRA2GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGBA2GRAY)
+GPU_TEST_P(CvtColor, RGBA2GRAY)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
@@ -233,7 +231,7 @@ TEST_P(CvtColor, RGBA2GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2BGR565)
+GPU_TEST_P(CvtColor, BGR2BGR565)
 {
     if (depth != CV_8U)
         return;
@@ -249,7 +247,7 @@ TEST_P(CvtColor, BGR2BGR565)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, RGB2BGR565)
+GPU_TEST_P(CvtColor, RGB2BGR565)
 {
     if (depth != CV_8U)
         return;
@@ -265,7 +263,7 @@ TEST_P(CvtColor, RGB2BGR565)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5652BGR)
+GPU_TEST_P(CvtColor, BGR5652BGR)
 {
     if (depth != CV_8U)
         return;
@@ -282,7 +280,7 @@ TEST_P(CvtColor, BGR5652BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5652RGB)
+GPU_TEST_P(CvtColor, BGR5652RGB)
 {
     if (depth != CV_8U)
         return;
@@ -299,7 +297,7 @@ TEST_P(CvtColor, BGR5652RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2BGR565)
+GPU_TEST_P(CvtColor, BGRA2BGR565)
 {
     if (depth != CV_8U)
         return;
@@ -316,7 +314,7 @@ TEST_P(CvtColor, BGRA2BGR565)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, RGBA2BGR565)
+GPU_TEST_P(CvtColor, RGBA2BGR565)
 {
     if (depth != CV_8U)
         return;
@@ -333,7 +331,7 @@ TEST_P(CvtColor, RGBA2BGR565)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5652BGRA)
+GPU_TEST_P(CvtColor, BGR5652BGRA)
 {
     if (depth != CV_8U)
         return;
@@ -350,7 +348,7 @@ TEST_P(CvtColor, BGR5652BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5652RGBA)
+GPU_TEST_P(CvtColor, BGR5652RGBA)
 {
     if (depth != CV_8U)
         return;
@@ -367,7 +365,7 @@ TEST_P(CvtColor, BGR5652RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, GRAY2BGR565)
+GPU_TEST_P(CvtColor, GRAY2BGR565)
 {
     if (depth != CV_8U)
         return;
@@ -384,7 +382,7 @@ TEST_P(CvtColor, GRAY2BGR565)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5652GRAY)
+GPU_TEST_P(CvtColor, BGR5652GRAY)
 {
     if (depth != CV_8U)
         return;
@@ -401,7 +399,7 @@ TEST_P(CvtColor, BGR5652GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR2BGR555)
+GPU_TEST_P(CvtColor, BGR2BGR555)
 {
     if (depth != CV_8U)
         return;
@@ -417,7 +415,7 @@ TEST_P(CvtColor, BGR2BGR555)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, RGB2BGR555)
+GPU_TEST_P(CvtColor, RGB2BGR555)
 {
     if (depth != CV_8U)
         return;
@@ -433,7 +431,7 @@ TEST_P(CvtColor, RGB2BGR555)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5552BGR)
+GPU_TEST_P(CvtColor, BGR5552BGR)
 {
     if (depth != CV_8U)
         return;
@@ -450,7 +448,7 @@ TEST_P(CvtColor, BGR5552BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5552RGB)
+GPU_TEST_P(CvtColor, BGR5552RGB)
 {
     if (depth != CV_8U)
         return;
@@ -467,7 +465,7 @@ TEST_P(CvtColor, BGR5552RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGRA2BGR555)
+GPU_TEST_P(CvtColor, BGRA2BGR555)
 {
     if (depth != CV_8U)
         return;
@@ -484,7 +482,7 @@ TEST_P(CvtColor, BGRA2BGR555)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, RGBA2BGR555)
+GPU_TEST_P(CvtColor, RGBA2BGR555)
 {
     if (depth != CV_8U)
         return;
@@ -501,7 +499,7 @@ TEST_P(CvtColor, RGBA2BGR555)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5552BGRA)
+GPU_TEST_P(CvtColor, BGR5552BGRA)
 {
     if (depth != CV_8U)
         return;
@@ -518,7 +516,7 @@ TEST_P(CvtColor, BGR5552BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5552RGBA)
+GPU_TEST_P(CvtColor, BGR5552RGBA)
 {
     if (depth != CV_8U)
         return;
@@ -535,7 +533,7 @@ TEST_P(CvtColor, BGR5552RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, GRAY2BGR555)
+GPU_TEST_P(CvtColor, GRAY2BGR555)
 {
     if (depth != CV_8U)
         return;
@@ -552,7 +550,7 @@ TEST_P(CvtColor, GRAY2BGR555)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR5552GRAY)
+GPU_TEST_P(CvtColor, BGR5552GRAY)
 {
     if (depth != CV_8U)
         return;
@@ -569,7 +567,7 @@ TEST_P(CvtColor, BGR5552GRAY)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(CvtColor, BGR2XYZ)
+GPU_TEST_P(CvtColor, BGR2XYZ)
 {
     cv::Mat src = img;
 
@@ -582,7 +580,7 @@ TEST_P(CvtColor, BGR2XYZ)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGB2XYZ)
+GPU_TEST_P(CvtColor, RGB2XYZ)
 {
     cv::Mat src = img;
 
@@ -595,7 +593,7 @@ TEST_P(CvtColor, RGB2XYZ)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2XYZ4)
+GPU_TEST_P(CvtColor, BGR2XYZ4)
 {
     cv::Mat src = img;
 
@@ -616,7 +614,7 @@ TEST_P(CvtColor, BGR2XYZ4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGRA2XYZ4)
+GPU_TEST_P(CvtColor, BGRA2XYZ4)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2BGRA);
@@ -638,7 +636,7 @@ TEST_P(CvtColor, BGRA2XYZ4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, XYZ2BGR)
+GPU_TEST_P(CvtColor, XYZ2BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
@@ -652,7 +650,7 @@ TEST_P(CvtColor, XYZ2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, XYZ2RGB)
+GPU_TEST_P(CvtColor, XYZ2RGB)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
@@ -666,7 +664,7 @@ TEST_P(CvtColor, XYZ2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, XYZ42BGR)
+GPU_TEST_P(CvtColor, XYZ42BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
@@ -685,7 +683,7 @@ TEST_P(CvtColor, XYZ42BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, XYZ42BGRA)
+GPU_TEST_P(CvtColor, XYZ42BGRA)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2XYZ);
@@ -704,7 +702,7 @@ TEST_P(CvtColor, XYZ42BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2YCrCb)
+GPU_TEST_P(CvtColor, BGR2YCrCb)
 {
     cv::Mat src = img;
 
@@ -717,7 +715,7 @@ TEST_P(CvtColor, BGR2YCrCb)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGB2YCrCb)
+GPU_TEST_P(CvtColor, RGB2YCrCb)
 {
     cv::Mat src = img;
 
@@ -730,7 +728,7 @@ TEST_P(CvtColor, RGB2YCrCb)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2YCrCb4)
+GPU_TEST_P(CvtColor, BGR2YCrCb4)
 {
     cv::Mat src = img;
 
@@ -751,7 +749,7 @@ TEST_P(CvtColor, BGR2YCrCb4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGBA2YCrCb4)
+GPU_TEST_P(CvtColor, RGBA2YCrCb4)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
@@ -773,7 +771,7 @@ TEST_P(CvtColor, RGBA2YCrCb4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, YCrCb2BGR)
+GPU_TEST_P(CvtColor, YCrCb2BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
@@ -787,7 +785,7 @@ TEST_P(CvtColor, YCrCb2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YCrCb2RGB)
+GPU_TEST_P(CvtColor, YCrCb2RGB)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
@@ -801,7 +799,7 @@ TEST_P(CvtColor, YCrCb2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YCrCb42RGB)
+GPU_TEST_P(CvtColor, YCrCb42RGB)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
@@ -820,7 +818,7 @@ TEST_P(CvtColor, YCrCb42RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YCrCb42RGBA)
+GPU_TEST_P(CvtColor, YCrCb42RGBA)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YCrCb);
@@ -839,7 +837,7 @@ TEST_P(CvtColor, YCrCb42RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2HSV)
+GPU_TEST_P(CvtColor, BGR2HSV)
 {
     if (depth == CV_16U)
         return;
@@ -855,7 +853,7 @@ TEST_P(CvtColor, BGR2HSV)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HSV)
+GPU_TEST_P(CvtColor, RGB2HSV)
 {
     if (depth == CV_16U)
         return;
@@ -871,7 +869,7 @@ TEST_P(CvtColor, RGB2HSV)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HSV4)
+GPU_TEST_P(CvtColor, RGB2HSV4)
 {
     if (depth == CV_16U)
         return;
@@ -895,7 +893,7 @@ TEST_P(CvtColor, RGB2HSV4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGBA2HSV4)
+GPU_TEST_P(CvtColor, RGBA2HSV4)
 {
     if (depth == CV_16U)
         return;
@@ -920,7 +918,7 @@ TEST_P(CvtColor, RGBA2HSV4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, BGR2HLS)
+GPU_TEST_P(CvtColor, BGR2HLS)
 {
     if (depth == CV_16U)
         return;
@@ -936,7 +934,7 @@ TEST_P(CvtColor, BGR2HLS)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HLS)
+GPU_TEST_P(CvtColor, RGB2HLS)
 {
     if (depth == CV_16U)
         return;
@@ -952,7 +950,7 @@ TEST_P(CvtColor, RGB2HLS)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HLS4)
+GPU_TEST_P(CvtColor, RGB2HLS4)
 {
     if (depth == CV_16U)
         return;
@@ -976,7 +974,7 @@ TEST_P(CvtColor, RGB2HLS4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGBA2HLS4)
+GPU_TEST_P(CvtColor, RGBA2HLS4)
 {
     if (depth == CV_16U)
         return;
@@ -1001,7 +999,7 @@ TEST_P(CvtColor, RGBA2HLS4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV2BGR)
+GPU_TEST_P(CvtColor, HSV2BGR)
 {
     if (depth == CV_16U)
         return;
@@ -1018,7 +1016,7 @@ TEST_P(CvtColor, HSV2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV2RGB)
+GPU_TEST_P(CvtColor, HSV2RGB)
 {
     if (depth == CV_16U)
         return;
@@ -1035,7 +1033,7 @@ TEST_P(CvtColor, HSV2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV42BGR)
+GPU_TEST_P(CvtColor, HSV42BGR)
 {
     if (depth == CV_16U)
         return;
@@ -1057,7 +1055,7 @@ TEST_P(CvtColor, HSV42BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV42BGRA)
+GPU_TEST_P(CvtColor, HSV42BGRA)
 {
     if (depth == CV_16U)
         return;
@@ -1079,7 +1077,7 @@ TEST_P(CvtColor, HSV42BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS2BGR)
+GPU_TEST_P(CvtColor, HLS2BGR)
 {
     if (depth == CV_16U)
         return;
@@ -1096,7 +1094,7 @@ TEST_P(CvtColor, HLS2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS2RGB)
+GPU_TEST_P(CvtColor, HLS2RGB)
 {
     if (depth == CV_16U)
         return;
@@ -1113,7 +1111,7 @@ TEST_P(CvtColor, HLS2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS42RGB)
+GPU_TEST_P(CvtColor, HLS42RGB)
 {
     if (depth == CV_16U)
         return;
@@ -1135,7 +1133,7 @@ TEST_P(CvtColor, HLS42RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS42RGBA)
+GPU_TEST_P(CvtColor, HLS42RGBA)
 {
     if (depth == CV_16U)
         return;
@@ -1158,7 +1156,7 @@ TEST_P(CvtColor, HLS42RGBA)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, BGR2HSV_FULL)
+GPU_TEST_P(CvtColor, BGR2HSV_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1174,7 +1172,7 @@ TEST_P(CvtColor, BGR2HSV_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HSV_FULL)
+GPU_TEST_P(CvtColor, RGB2HSV_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1190,7 +1188,7 @@ TEST_P(CvtColor, RGB2HSV_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HSV4_FULL)
+GPU_TEST_P(CvtColor, RGB2HSV4_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1214,7 +1212,7 @@ TEST_P(CvtColor, RGB2HSV4_FULL)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGBA2HSV4_FULL)
+GPU_TEST_P(CvtColor, RGBA2HSV4_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1239,7 +1237,7 @@ TEST_P(CvtColor, RGBA2HSV4_FULL)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, BGR2HLS_FULL)
+GPU_TEST_P(CvtColor, BGR2HLS_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1255,7 +1253,7 @@ TEST_P(CvtColor, BGR2HLS_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HLS_FULL)
+GPU_TEST_P(CvtColor, RGB2HLS_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1271,7 +1269,7 @@ TEST_P(CvtColor, RGB2HLS_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGB2HLS4_FULL)
+GPU_TEST_P(CvtColor, RGB2HLS4_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1295,7 +1293,7 @@ TEST_P(CvtColor, RGB2HLS4_FULL)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, RGBA2HLS4_FULL)
+GPU_TEST_P(CvtColor, RGBA2HLS4_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1320,7 +1318,7 @@ TEST_P(CvtColor, RGBA2HLS4_FULL)
     EXPECT_MAT_NEAR(dst_gold, h_dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV2BGR_FULL)
+GPU_TEST_P(CvtColor, HSV2BGR_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1337,7 +1335,7 @@ TEST_P(CvtColor, HSV2BGR_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV2RGB_FULL)
+GPU_TEST_P(CvtColor, HSV2RGB_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1354,7 +1352,7 @@ TEST_P(CvtColor, HSV2RGB_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV42RGB_FULL)
+GPU_TEST_P(CvtColor, HSV42RGB_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1376,7 +1374,7 @@ TEST_P(CvtColor, HSV42RGB_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HSV42RGBA_FULL)
+GPU_TEST_P(CvtColor, HSV42RGBA_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1398,7 +1396,7 @@ TEST_P(CvtColor, HSV42RGBA_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS2BGR_FULL)
+GPU_TEST_P(CvtColor, HLS2BGR_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1415,7 +1413,7 @@ TEST_P(CvtColor, HLS2BGR_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS2RGB_FULL)
+GPU_TEST_P(CvtColor, HLS2RGB_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1432,7 +1430,7 @@ TEST_P(CvtColor, HLS2RGB_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS42RGB_FULL)
+GPU_TEST_P(CvtColor, HLS42RGB_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1454,7 +1452,7 @@ TEST_P(CvtColor, HLS42RGB_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, HLS42RGBA_FULL)
+GPU_TEST_P(CvtColor, HLS42RGBA_FULL)
 {
     if (depth == CV_16U)
         return;
@@ -1476,7 +1474,7 @@ TEST_P(CvtColor, HLS42RGBA_FULL)
     EXPECT_MAT_NEAR(dst_gold, dst, depth == CV_32F ? 1e-2 : 1);
 }
 
-TEST_P(CvtColor, BGR2YUV)
+GPU_TEST_P(CvtColor, BGR2YUV)
 {
     cv::Mat src = img;
 
@@ -1489,7 +1487,7 @@ TEST_P(CvtColor, BGR2YUV)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGB2YUV)
+GPU_TEST_P(CvtColor, RGB2YUV)
 {
     cv::Mat src = img;
 
@@ -1502,7 +1500,7 @@ TEST_P(CvtColor, RGB2YUV)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YUV2BGR)
+GPU_TEST_P(CvtColor, YUV2BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
@@ -1516,7 +1514,7 @@ TEST_P(CvtColor, YUV2BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YUV42BGR)
+GPU_TEST_P(CvtColor, YUV42BGR)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
@@ -1535,7 +1533,7 @@ TEST_P(CvtColor, YUV42BGR)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YUV42BGRA)
+GPU_TEST_P(CvtColor, YUV42BGRA)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2YUV);
@@ -1554,7 +1552,7 @@ TEST_P(CvtColor, YUV42BGRA)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, YUV2RGB)
+GPU_TEST_P(CvtColor, YUV2RGB)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_RGB2YUV);
@@ -1568,7 +1566,7 @@ TEST_P(CvtColor, YUV2RGB)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2YUV4)
+GPU_TEST_P(CvtColor, BGR2YUV4)
 {
     cv::Mat src = img;
 
@@ -1589,7 +1587,7 @@ TEST_P(CvtColor, BGR2YUV4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, RGBA2YUV4)
+GPU_TEST_P(CvtColor, RGBA2YUV4)
 {
     cv::Mat src;
     cv::cvtColor(img, src, cv::COLOR_BGR2RGBA);
@@ -1611,147 +1609,91 @@ TEST_P(CvtColor, RGBA2YUV4)
     EXPECT_MAT_NEAR(dst_gold, h_dst, 1e-5);
 }
 
-TEST_P(CvtColor, BGR2Lab)
+#if defined (CUDA_VERSION) && (CUDA_VERSION >= 5000)
+
+GPU_TEST_P(CvtColor, BGR2Lab)
 {
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = readImage("stereobm/aloe-L.png");
+    cv::Mat src = readImage("stereobm/aloe-L.png");
 
-        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
+    cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_BGR2Lab);
 
-        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
+    cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2BGR);
 
-        EXPECT_MAT_NEAR(src, dst_bgr, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
+    EXPECT_MAT_NEAR(src, dst_bgr, 10);
 }
 
-TEST_P(CvtColor, RGB2Lab)
+GPU_TEST_P(CvtColor, RGB2Lab)
 {
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = readImage("stereobm/aloe-L.png");
+    cv::Mat src = readImage("stereobm/aloe-L.png");
 
-        cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
+    cv::gpu::GpuMat dst_lab = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst_lab, cv::COLOR_RGB2Lab);
 
-        cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
+    cv::gpu::GpuMat dst_bgr = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(dst_lab, dst_bgr, cv::COLOR_Lab2RGB);
 
-        EXPECT_MAT_NEAR(src, dst_bgr, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
+    EXPECT_MAT_NEAR(src, dst_bgr, 10);
 }
 
-TEST_P(CvtColor, BGR2Luv)
+GPU_TEST_P(CvtColor, BGR2Luv)
 {
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
+    cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_BGR2Luv);
 
-        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
+    cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2BGR);
 
-        EXPECT_MAT_NEAR(src, dst_rgb, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
+    EXPECT_MAT_NEAR(src, dst_rgb, 10);
 }
 
-TEST_P(CvtColor, RGB2Luv)
+GPU_TEST_P(CvtColor, RGB2Luv)
 {
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = img;
+    cv::Mat src = img;
 
-        cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
+    cv::gpu::GpuMat dst_luv = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst_luv, cv::COLOR_RGB2Luv);
 
-        cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
+    cv::gpu::GpuMat dst_rgb = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(dst_luv, dst_rgb, cv::COLOR_Luv2RGB);
 
-        EXPECT_MAT_NEAR(src, dst_rgb, 10);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
+    EXPECT_MAT_NEAR(src, dst_rgb, 10);
 }
 
-TEST_P(CvtColor, RGBA2mRGBA)
+GPU_TEST_P(CvtColor, RGBA2mRGBA)
 {
     if (depth != CV_8U)
         return;
 
-    try
-    {
-        cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
+    cv::Mat src = randomMat(size, CV_MAKE_TYPE(depth, 4));
 
-        cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
-        cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
+    cv::gpu::GpuMat dst = createMat(src.size(), src.type(), useRoi);
+    cv::gpu::cvtColor(loadMat(src, useRoi), dst, cv::COLOR_RGBA2mRGBA);
 
-        cv::Mat dst_gold;
-        cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
+    cv::Mat dst_gold;
+    cv::cvtColor(src, dst_gold, cv::COLOR_RGBA2mRGBA);
 
-        EXPECT_MAT_NEAR(dst_gold, dst, 1);
-    }
-    catch (const cv::Exception& e)
-    {
-        (void)e;
-#if defined (CUDA_VERSION) && (CUDA_VERSION < 5000)
-        ASSERT_EQ(CV_StsBadFlag, e.code);
-#else
-        FAIL();
-#endif
-    }
+    EXPECT_MAT_NEAR(dst_gold, dst, 1);
 }
 
-TEST_P(CvtColor, BayerBG2BGR)
+#endif // defined (CUDA_VERSION) && (CUDA_VERSION >= 5000)
+
+GPU_TEST_P(CvtColor, BayerBG2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1767,7 +1709,7 @@ TEST_P(CvtColor, BayerBG2BGR)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerBG2BGR4)
+GPU_TEST_P(CvtColor, BayerBG2BGR4)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1790,7 +1732,7 @@ TEST_P(CvtColor, BayerBG2BGR4)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerGB2BGR)
+GPU_TEST_P(CvtColor, BayerGB2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1806,7 +1748,7 @@ TEST_P(CvtColor, BayerGB2BGR)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerGB2BGR4)
+GPU_TEST_P(CvtColor, BayerGB2BGR4)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1828,7 +1770,7 @@ TEST_P(CvtColor, BayerGB2BGR4)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerRG2BGR)
+GPU_TEST_P(CvtColor, BayerRG2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1844,7 +1786,7 @@ TEST_P(CvtColor, BayerRG2BGR)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerRG2BGR4)
+GPU_TEST_P(CvtColor, BayerRG2BGR4)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1866,7 +1808,7 @@ TEST_P(CvtColor, BayerRG2BGR4)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst3(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerGR2BGR)
+GPU_TEST_P(CvtColor, BayerGR2BGR)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1882,7 +1824,7 @@ TEST_P(CvtColor, BayerGR2BGR)
     EXPECT_MAT_NEAR(dst_gold(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), dst(cv::Rect(1, 1, dst.cols - 2, dst.rows - 2)), 0);
 }
 
-TEST_P(CvtColor, BayerGR2BGR4)
+GPU_TEST_P(CvtColor, BayerGR2BGR4)
 {
     if ((depth != CV_8U && depth != CV_16U) || useRoi)
         return;
@@ -1929,7 +1871,7 @@ PARAM_TEST_CASE(SwapChannels, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(SwapChannels, Accuracy)
+GPU_TEST_P(SwapChannels, Accuracy)
 {
     cv::Mat src = readImageType("stereobm/aloe-L.png", CV_8UC4);
     ASSERT_FALSE(src.empty());
@@ -1950,6 +1892,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, SwapChannels, testing::Combine(
     DIFFERENT_SIZES,
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_copy_make_border.cpp b/modules/gpu/test/test_copy_make_border.cpp
index 0efd9ec68..0b59fe2d8 100644
--- a/modules/gpu/test/test_copy_make_border.cpp
+++ b/modules/gpu/test/test_copy_make_border.cpp
@@ -43,9 +43,10 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
-IMPLEMENT_PARAM_CLASS(Border, int)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(Border, int)
+}
 
 PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border, BorderType, UseRoi)
 {
@@ -69,7 +70,7 @@ PARAM_TEST_CASE(CopyMakeBorder, cv::gpu::DeviceInfo, cv::Size, MatType, Border,
     }
 };
 
-TEST_P(CopyMakeBorder, Accuracy)
+GPU_TEST_P(CopyMakeBorder, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Scalar val = randomScalar(0, 255);
@@ -99,6 +100,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CopyMakeBorder, testing::Combine(
     ALL_BORDER_TYPES,
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_core.cpp b/modules/gpu/test/test_core.cpp
index 695ec9758..e6745abe3 100644
--- a/modules/gpu/test/test_core.cpp
+++ b/modules/gpu/test/test_core.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 ////////////////////////////////////////////////////////////////////////////////
 // Merge
 
@@ -68,7 +66,7 @@ PARAM_TEST_CASE(Merge, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
     }
 };
 
-TEST_P(Merge, Accuracy)
+GPU_TEST_P(Merge, Accuracy)
 {
     std::vector<cv::Mat> src;
     src.reserve(channels);
@@ -137,7 +135,7 @@ PARAM_TEST_CASE(Split, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi
     }
 };
 
-TEST_P(Split, Accuracy)
+GPU_TEST_P(Split, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -206,7 +204,7 @@ PARAM_TEST_CASE(Add_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, Ma
     }
 };
 
-TEST_P(Add_Array, Accuracy)
+GPU_TEST_P(Add_Array, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -267,7 +265,7 @@ PARAM_TEST_CASE(Add_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
     }
 };
 
-TEST_P(Add_Array_Mask, Accuracy)
+GPU_TEST_P(Add_Array_Mask, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -325,7 +323,7 @@ PARAM_TEST_CASE(Add_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth, M
     }
 };
 
-TEST_P(Add_Scalar, WithOutMask)
+GPU_TEST_P(Add_Scalar, WithOutMask)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -355,7 +353,7 @@ TEST_P(Add_Scalar, WithOutMask)
     }
 }
 
-TEST_P(Add_Scalar, WithMask)
+GPU_TEST_P(Add_Scalar, WithMask)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -421,7 +419,7 @@ PARAM_TEST_CASE(Subtract_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
     }
 };
 
-TEST_P(Subtract_Array, Accuracy)
+GPU_TEST_P(Subtract_Array, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -482,7 +480,7 @@ PARAM_TEST_CASE(Subtract_Array_Mask, cv::gpu::DeviceInfo, cv::Size, std::pair<Ma
     }
 };
 
-TEST_P(Subtract_Array_Mask, Accuracy)
+GPU_TEST_P(Subtract_Array_Mask, Accuracy)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -540,7 +538,7 @@ PARAM_TEST_CASE(Subtract_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
     }
 };
 
-TEST_P(Subtract_Scalar, WithOutMask)
+GPU_TEST_P(Subtract_Scalar, WithOutMask)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -570,7 +568,7 @@ TEST_P(Subtract_Scalar, WithOutMask)
     }
 }
 
-TEST_P(Subtract_Scalar, WithMask)
+GPU_TEST_P(Subtract_Scalar, WithMask)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -636,7 +634,7 @@ PARAM_TEST_CASE(Multiply_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDept
     }
 };
 
-TEST_P(Multiply_Array, WithOutScale)
+GPU_TEST_P(Multiply_Array, WithOutScale)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -665,7 +663,7 @@ TEST_P(Multiply_Array, WithOutScale)
     }
 }
 
-TEST_P(Multiply_Array, WithScale)
+GPU_TEST_P(Multiply_Array, WithScale)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype);
@@ -721,7 +719,7 @@ PARAM_TEST_CASE(Multiply_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
+GPU_TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
 {
     cv::Mat mat1 = randomMat(size, CV_8UC4);
     cv::Mat mat2 = randomMat(size, CV_32FC1);
@@ -758,7 +756,7 @@ TEST_P(Multiply_Array_Special, Case_8UC4x_32FC1)
     }
 }
 
-TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
+GPU_TEST_P(Multiply_Array_Special, Case_16SC4x_32FC1)
 {
     cv::Mat mat1 = randomMat(size, CV_16SC4);
     cv::Mat mat2 = randomMat(size, CV_32FC1);
@@ -821,7 +819,7 @@ PARAM_TEST_CASE(Multiply_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDep
     }
 };
 
-TEST_P(Multiply_Scalar, WithOutScale)
+GPU_TEST_P(Multiply_Scalar, WithOutScale)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -851,7 +849,7 @@ TEST_P(Multiply_Scalar, WithOutScale)
 }
 
 
-TEST_P(Multiply_Scalar, WithScale)
+GPU_TEST_P(Multiply_Scalar, WithScale)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(0, 255);
@@ -916,7 +914,7 @@ PARAM_TEST_CASE(Divide_Array, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth,
     }
 };
 
-TEST_P(Divide_Array, WithOutScale)
+GPU_TEST_P(Divide_Array, WithOutScale)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
@@ -945,8 +943,7 @@ TEST_P(Divide_Array, WithOutScale)
     }
 }
 
-
-TEST_P(Divide_Array, WithScale)
+GPU_TEST_P(Divide_Array, WithScale)
 {
     cv::Mat mat1 = randomMat(size, stype);
     cv::Mat mat2 = randomMat(size, stype, 1.0, 255.0);
@@ -1002,7 +999,7 @@ PARAM_TEST_CASE(Divide_Array_Special, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
+GPU_TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
 {
     cv::Mat mat1 = randomMat(size, CV_8UC4);
     cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
@@ -1039,7 +1036,7 @@ TEST_P(Divide_Array_Special, Case_8UC4x_32FC1)
     }
 }
 
-TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
+GPU_TEST_P(Divide_Array_Special, Case_16SC4x_32FC1)
 {
     cv::Mat mat1 = randomMat(size, CV_16SC4);
     cv::Mat mat2 = randomMat(size, CV_32FC1, 1.0, 255.0);
@@ -1102,7 +1099,7 @@ PARAM_TEST_CASE(Divide_Scalar, cv::gpu::DeviceInfo, cv::Size, std::pair<MatDepth
     }
 };
 
-TEST_P(Divide_Scalar, WithOutScale)
+GPU_TEST_P(Divide_Scalar, WithOutScale)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(1.0, 255.0);
@@ -1131,7 +1128,7 @@ TEST_P(Divide_Scalar, WithOutScale)
     }
 }
 
-TEST_P(Divide_Scalar, WithScale)
+GPU_TEST_P(Divide_Scalar, WithScale)
 {
     cv::Mat mat = randomMat(size, depth.first);
     cv::Scalar val = randomScalar(1.0, 255.0);
@@ -1188,7 +1185,7 @@ PARAM_TEST_CASE(Divide_Scalar_Inv, cv::gpu::DeviceInfo, cv::Size, std::pair<MatD
     }
 };
 
-TEST_P(Divide_Scalar_Inv, Accuracy)
+GPU_TEST_P(Divide_Scalar_Inv, Accuracy)
 {
     double scale = randomDouble(0.0, 255.0);
     cv::Mat mat = randomMat(size, depth.first, 1.0, 255.0);
@@ -1244,7 +1241,7 @@ PARAM_TEST_CASE(AbsDiff, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(AbsDiff, Array)
+GPU_TEST_P(AbsDiff, Array)
 {
     cv::Mat src1 = randomMat(size, depth);
     cv::Mat src2 = randomMat(size, depth);
@@ -1273,7 +1270,7 @@ TEST_P(AbsDiff, Array)
     }
 }
 
-TEST_P(AbsDiff, Scalar)
+GPU_TEST_P(AbsDiff, Scalar)
 {
     cv::Mat src = randomMat(size, depth);
     cv::Scalar val = randomScalar(0.0, 255.0);
@@ -1329,7 +1326,7 @@ PARAM_TEST_CASE(Abs, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Abs, Accuracy)
+GPU_TEST_P(Abs, Accuracy)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -1368,7 +1365,7 @@ PARAM_TEST_CASE(Sqr, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Sqr, Accuracy)
+GPU_TEST_P(Sqr, Accuracy)
 {
     cv::Mat src = randomMat(size, depth, 0, depth == CV_8U ? 16 : 255);
 
@@ -1393,28 +1390,31 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Sqr, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // Sqrt
 
-template <typename T> void sqrtImpl(const cv::Mat& src, cv::Mat& dst)
+namespace
 {
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T> void sqrtImpl(const cv::Mat& src, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
-            dst.at<T>(y, x) = static_cast<T>(std::sqrt(static_cast<float>(src.at<T>(y, x))));
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            for (int x = 0; x < src.cols; ++x)
+                dst.at<T>(y, x) = static_cast<T>(std::sqrt(static_cast<float>(src.at<T>(y, x))));
+        }
     }
-}
 
-void sqrtGold(const cv::Mat& src, cv::Mat& dst)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
-    const func_t funcs[] =
+    void sqrtGold(const cv::Mat& src, cv::Mat& dst)
     {
-        sqrtImpl<uchar>, sqrtImpl<schar>, sqrtImpl<ushort>, sqrtImpl<short>,
-        sqrtImpl<int>, sqrtImpl<float>
-    };
+        typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-    funcs[src.depth()](src, dst);
+        const func_t funcs[] =
+        {
+            sqrtImpl<uchar>, sqrtImpl<schar>, sqrtImpl<ushort>, sqrtImpl<short>,
+            sqrtImpl<int>, sqrtImpl<float>
+        };
+
+        funcs[src.depth()](src, dst);
+    }
 }
 
 PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
@@ -1435,7 +1435,7 @@ PARAM_TEST_CASE(Sqrt, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Sqrt, Accuracy)
+GPU_TEST_P(Sqrt, Accuracy)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -1460,28 +1460,31 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Sqrt, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // Log
 
-template <typename T> void logImpl(const cv::Mat& src, cv::Mat& dst)
+namespace
 {
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T> void logImpl(const cv::Mat& src, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
-            dst.at<T>(y, x) = static_cast<T>(std::log(static_cast<float>(src.at<T>(y, x))));
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            for (int x = 0; x < src.cols; ++x)
+                dst.at<T>(y, x) = static_cast<T>(std::log(static_cast<float>(src.at<T>(y, x))));
+        }
     }
-}
 
-void logGold(const cv::Mat& src, cv::Mat& dst)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
-    const func_t funcs[] =
+    void logGold(const cv::Mat& src, cv::Mat& dst)
     {
-        logImpl<uchar>, logImpl<schar>, logImpl<ushort>, logImpl<short>,
-        logImpl<int>, logImpl<float>
-    };
+        typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-    funcs[src.depth()](src, dst);
+        const func_t funcs[] =
+        {
+            logImpl<uchar>, logImpl<schar>, logImpl<ushort>, logImpl<short>,
+            logImpl<int>, logImpl<float>
+        };
+
+        funcs[src.depth()](src, dst);
+    }
 }
 
 PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
@@ -1502,7 +1505,7 @@ PARAM_TEST_CASE(Log, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Log, Accuracy)
+GPU_TEST_P(Log, Accuracy)
 {
     cv::Mat src = randomMat(size, depth, 1.0, 255.0);
 
@@ -1527,38 +1530,41 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Log, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // Exp
 
-template <typename T> void expImpl(const cv::Mat& src, cv::Mat& dst)
+namespace
 {
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T> void expImpl(const cv::Mat& src, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
-            dst.at<T>(y, x) = cv::saturate_cast<T>(static_cast<int>(std::exp(static_cast<float>(src.at<T>(y, x)))));
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            for (int x = 0; x < src.cols; ++x)
+                dst.at<T>(y, x) = cv::saturate_cast<T>(static_cast<int>(std::exp(static_cast<float>(src.at<T>(y, x)))));
+        }
     }
-}
-void expImpl_float(const cv::Mat& src, cv::Mat& dst)
-{
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    void expImpl_float(const cv::Mat& src, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
-            dst.at<float>(y, x) = std::exp(static_cast<float>(src.at<float>(y, x)));
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            for (int x = 0; x < src.cols; ++x)
+                dst.at<float>(y, x) = std::exp(static_cast<float>(src.at<float>(y, x)));
+        }
     }
-}
 
-void expGold(const cv::Mat& src, cv::Mat& dst)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
-
-    const func_t funcs[] =
+    void expGold(const cv::Mat& src, cv::Mat& dst)
     {
-        expImpl<uchar>, expImpl<schar>, expImpl<ushort>, expImpl<short>,
-        expImpl<int>, expImpl_float
-    };
+        typedef void (*func_t)(const cv::Mat& src, cv::Mat& dst);
 
-    funcs[src.depth()](src, dst);
+        const func_t funcs[] =
+        {
+            expImpl<uchar>, expImpl<schar>, expImpl<ushort>, expImpl<short>,
+            expImpl<int>, expImpl_float
+        };
+
+        funcs[src.depth()](src, dst);
+    }
 }
 
 PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
@@ -1579,7 +1585,7 @@ PARAM_TEST_CASE(Exp, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Exp, Accuracy)
+GPU_TEST_P(Exp, Accuracy)
 {
     cv::Mat src = randomMat(size, depth, 0.0, 10.0);
 
@@ -1627,7 +1633,7 @@ PARAM_TEST_CASE(Compare_Array, cv::gpu::DeviceInfo, cv::Size, MatDepth, CmpCode,
     }
 };
 
-TEST_P(Compare_Array, Accuracy)
+GPU_TEST_P(Compare_Array, Accuracy)
 {
     cv::Mat src1 = randomMat(size, depth);
     cv::Mat src2 = randomMat(size, depth);
@@ -1729,7 +1735,7 @@ PARAM_TEST_CASE(Compare_Scalar, cv::gpu::DeviceInfo, cv::Size, MatType, CmpCode,
     }
 };
 
-TEST_P(Compare_Scalar, Accuracy)
+GPU_TEST_P(Compare_Scalar, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Scalar sc = randomScalar(0.0, 255.0);
@@ -1799,7 +1805,7 @@ PARAM_TEST_CASE(Bitwise_Array, cv::gpu::DeviceInfo, cv::Size, MatType)
     }
 };
 
-TEST_P(Bitwise_Array, Not)
+GPU_TEST_P(Bitwise_Array, Not)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_not(loadMat(src1), dst);
@@ -1809,7 +1815,7 @@ TEST_P(Bitwise_Array, Not)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(Bitwise_Array, Or)
+GPU_TEST_P(Bitwise_Array, Or)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_or(loadMat(src1), loadMat(src2), dst);
@@ -1819,7 +1825,7 @@ TEST_P(Bitwise_Array, Or)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(Bitwise_Array, And)
+GPU_TEST_P(Bitwise_Array, And)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_and(loadMat(src1), loadMat(src2), dst);
@@ -1829,7 +1835,7 @@ TEST_P(Bitwise_Array, And)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(Bitwise_Array, Xor)
+GPU_TEST_P(Bitwise_Array, Xor)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_xor(loadMat(src1), loadMat(src2), dst);
@@ -1872,7 +1878,7 @@ PARAM_TEST_CASE(Bitwise_Scalar, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channel
     }
 };
 
-TEST_P(Bitwise_Scalar, Or)
+GPU_TEST_P(Bitwise_Scalar, Or)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_or(loadMat(src), val, dst);
@@ -1883,7 +1889,7 @@ TEST_P(Bitwise_Scalar, Or)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(Bitwise_Scalar, And)
+GPU_TEST_P(Bitwise_Scalar, And)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_and(loadMat(src), val, dst);
@@ -1894,7 +1900,7 @@ TEST_P(Bitwise_Scalar, And)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(Bitwise_Scalar, Xor)
+GPU_TEST_P(Bitwise_Scalar, Xor)
 {
     cv::gpu::GpuMat dst;
     cv::gpu::bitwise_xor(loadMat(src), val, dst);
@@ -1914,32 +1920,35 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Bitwise_Scalar, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // RShift
 
-template <typename T> void rhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+namespace
 {
-    const int cn = src.channels();
-
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T> void rhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
+        const int cn = src.channels();
+
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
         {
-            for (int c = 0; c < cn; ++c)
-                dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) >> val.val[c];
+            for (int x = 0; x < src.cols; ++x)
+            {
+                for (int c = 0; c < cn; ++c)
+                    dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) >> val.val[c];
+            }
         }
     }
-}
 
-void rhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
-
-    const func_t funcs[] =
+    void rhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
     {
-        rhiftImpl<uchar>, rhiftImpl<schar>, rhiftImpl<ushort>, rhiftImpl<short>, rhiftImpl<int>
-    };
+        typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
 
-    funcs[src.depth()](src, val, dst);
+        const func_t funcs[] =
+        {
+            rhiftImpl<uchar>, rhiftImpl<schar>, rhiftImpl<ushort>, rhiftImpl<short>, rhiftImpl<int>
+        };
+
+        funcs[src.depth()](src, val, dst);
+    }
 }
 
 PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
@@ -1962,7 +1971,7 @@ PARAM_TEST_CASE(RShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
     }
 };
 
-TEST_P(RShift, Accuracy)
+GPU_TEST_P(RShift, Accuracy)
 {
     int type = CV_MAKE_TYPE(depth, channels);
     cv::Mat src = randomMat(size, type);
@@ -1991,32 +2000,35 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, RShift, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // LShift
 
-template <typename T> void lhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
+namespace
 {
-    const int cn = src.channels();
-
-    dst.create(src.size(), src.type());
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T> void lhiftImpl(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
     {
-        for (int x = 0; x < src.cols; ++x)
+        const int cn = src.channels();
+
+        dst.create(src.size(), src.type());
+
+        for (int y = 0; y < src.rows; ++y)
         {
-            for (int c = 0; c < cn; ++c)
-                dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) << val.val[c];
+            for (int x = 0; x < src.cols; ++x)
+            {
+                for (int c = 0; c < cn; ++c)
+                    dst.at<T>(y, x * cn + c) = src.at<T>(y, x * cn + c) << val.val[c];
+            }
         }
     }
-}
 
-void lhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
-
-    const func_t funcs[] =
+    void lhiftGold(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst)
     {
-        lhiftImpl<uchar>, lhiftImpl<schar>, lhiftImpl<ushort>, lhiftImpl<short>, lhiftImpl<int>
-    };
+        typedef void (*func_t)(const cv::Mat& src, cv::Scalar_<int> val, cv::Mat& dst);
 
-    funcs[src.depth()](src, val, dst);
+        const func_t funcs[] =
+        {
+            lhiftImpl<uchar>, lhiftImpl<schar>, lhiftImpl<ushort>, lhiftImpl<short>, lhiftImpl<int>
+        };
+
+        funcs[src.depth()](src, val, dst);
+    }
 }
 
 PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
@@ -2039,7 +2051,7 @@ PARAM_TEST_CASE(LShift, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRo
     }
 };
 
-TEST_P(LShift, Accuracy)
+GPU_TEST_P(LShift, Accuracy)
 {
     int type = CV_MAKE_TYPE(depth, channels);
     cv::Mat src = randomMat(size, type);
@@ -2082,7 +2094,7 @@ PARAM_TEST_CASE(Min, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Min, Array)
+GPU_TEST_P(Min, Array)
 {
     cv::Mat src1 = randomMat(size, depth);
     cv::Mat src2 = randomMat(size, depth);
@@ -2110,7 +2122,7 @@ TEST_P(Min, Array)
     }
 }
 
-TEST_P(Min, Scalar)
+GPU_TEST_P(Min, Scalar)
 {
     cv::Mat src = randomMat(size, depth);
     double val = randomDouble(0.0, 255.0);
@@ -2165,7 +2177,7 @@ PARAM_TEST_CASE(Max, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Max, Array)
+GPU_TEST_P(Max, Array)
 {
     cv::Mat src1 = randomMat(size, depth);
     cv::Mat src2 = randomMat(size, depth);
@@ -2193,7 +2205,7 @@ TEST_P(Max, Array)
     }
 }
 
-TEST_P(Max, Scalar)
+GPU_TEST_P(Max, Scalar)
 {
     cv::Mat src = randomMat(size, depth);
     double val = randomDouble(0.0, 255.0);
@@ -2248,7 +2260,7 @@ PARAM_TEST_CASE(Pow, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(Pow, Accuracy)
+GPU_TEST_P(Pow, Accuracy)
 {
     cv::Mat src = randomMat(size, depth, 0.0, 10.0);
     double power = randomDouble(2.0, 4.0);
@@ -2311,7 +2323,7 @@ PARAM_TEST_CASE(AddWeighted, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth,
     }
 };
 
-TEST_P(AddWeighted, Accuracy)
+GPU_TEST_P(AddWeighted, Accuracy)
 {
     cv::Mat src1 = randomMat(size, depth1);
     cv::Mat src2 = randomMat(size, depth2);
@@ -2354,6 +2366,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, AddWeighted, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // GEMM
 
+#ifdef HAVE_CUBLAS
+
 CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T);
 #define ALL_GEMM_FLAGS testing::Values(GemmFlags(0), GemmFlags(cv::GEMM_1_T), GemmFlags(cv::GEMM_2_T), GemmFlags(cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_3_T), GemmFlags(cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T))
 
@@ -2377,7 +2391,7 @@ PARAM_TEST_CASE(GEMM, cv::gpu::DeviceInfo, cv::Size, MatType, GemmFlags, UseRoi)
     }
 };
 
-TEST_P(GEMM, Accuracy)
+GPU_TEST_P(GEMM, Accuracy)
 {
     cv::Mat src1 = randomMat(size, type, -10.0, 10.0);
     cv::Mat src2 = randomMat(size, type, -10.0, 10.0);
@@ -2385,17 +2399,6 @@ TEST_P(GEMM, Accuracy)
     double alpha = randomDouble(-10.0, 10.0);
     double beta = randomDouble(-10.0, 10.0);
 
-#ifndef HAVE_CUBLAS
-    try
-    {
-        cv::gpu::GpuMat dst;
-        cv::gpu::gemm(loadMat(src1), loadMat(src2), alpha, loadMat(src3), beta, dst, flags);
-    }
-    catch (const cv::Exception& e)
-    {
-        ASSERT_EQ(CV_StsNotImplemented, e.code);
-    }
-#else
     if (CV_MAT_DEPTH(type) == CV_64F && !supportFeature(devInfo, cv::gpu::NATIVE_DOUBLE))
     {
         try
@@ -2430,7 +2433,6 @@ TEST_P(GEMM, Accuracy)
 
         EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) == CV_32F ? 1e-1 : 1e-10);
     }
-#endif
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
@@ -2440,6 +2442,8 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, GEMM, testing::Combine(
     ALL_GEMM_FLAGS,
     WHOLE_SUBMAT));
 
+#endif // HAVE_CUBLAS
+
 ////////////////////////////////////////////////////////////////////////////////
 // Transpose
 
@@ -2461,7 +2465,7 @@ PARAM_TEST_CASE(Transpose, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(Transpose, Accuracy)
+GPU_TEST_P(Transpose, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -2528,7 +2532,7 @@ PARAM_TEST_CASE(Flip, cv::gpu::DeviceInfo, cv::Size, MatType, FlipCode, UseRoi)
     }
 };
 
-TEST_P(Flip, Accuracy)
+GPU_TEST_P(Flip, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -2580,7 +2584,7 @@ PARAM_TEST_CASE(LUT, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(LUT, OneChannel)
+GPU_TEST_P(LUT, OneChannel)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat lut = randomMat(cv::Size(256, 1), CV_8UC1);
@@ -2594,7 +2598,7 @@ TEST_P(LUT, OneChannel)
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
 
-TEST_P(LUT, MultiChannel)
+GPU_TEST_P(LUT, MultiChannel)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat lut = randomMat(cv::Size(256, 1), CV_MAKE_TYPE(CV_8U, src.channels()));
@@ -2633,7 +2637,7 @@ PARAM_TEST_CASE(Magnitude, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(Magnitude, NPP)
+GPU_TEST_P(Magnitude, NPP)
 {
     cv::Mat src = randomMat(size, CV_32FC2);
 
@@ -2648,7 +2652,7 @@ TEST_P(Magnitude, NPP)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
-TEST_P(Magnitude, Sqr_NPP)
+GPU_TEST_P(Magnitude, Sqr_NPP)
 {
     cv::Mat src = randomMat(size, CV_32FC2);
 
@@ -2664,7 +2668,7 @@ TEST_P(Magnitude, Sqr_NPP)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-1);
 }
 
-TEST_P(Magnitude, Accuracy)
+GPU_TEST_P(Magnitude, Accuracy)
 {
     cv::Mat x = randomMat(size, CV_32FC1);
     cv::Mat y = randomMat(size, CV_32FC1);
@@ -2678,7 +2682,7 @@ TEST_P(Magnitude, Accuracy)
     EXPECT_MAT_NEAR(dst_gold, dst, 1e-4);
 }
 
-TEST_P(Magnitude, Sqr_Accuracy)
+GPU_TEST_P(Magnitude, Sqr_Accuracy)
 {
     cv::Mat x = randomMat(size, CV_32FC1);
     cv::Mat y = randomMat(size, CV_32FC1);
@@ -2701,7 +2705,10 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Magnitude, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // Phase
 
-IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(AngleInDegrees, bool)
+}
 
 PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
 {
@@ -2721,7 +2728,7 @@ PARAM_TEST_CASE(Phase, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseRoi)
     }
 };
 
-TEST_P(Phase, Accuracy)
+GPU_TEST_P(Phase, Accuracy)
 {
     cv::Mat x = randomMat(size, CV_32FC1);
     cv::Mat y = randomMat(size, CV_32FC1);
@@ -2762,7 +2769,7 @@ PARAM_TEST_CASE(CartToPolar, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
     }
 };
 
-TEST_P(CartToPolar, Accuracy)
+GPU_TEST_P(CartToPolar, Accuracy)
 {
     cv::Mat x = randomMat(size, CV_32FC1);
     cv::Mat y = randomMat(size, CV_32FC1);
@@ -2806,7 +2813,7 @@ PARAM_TEST_CASE(PolarToCart, cv::gpu::DeviceInfo, cv::Size, AngleInDegrees, UseR
     }
 };
 
-TEST_P(PolarToCart, Accuracy)
+GPU_TEST_P(PolarToCart, Accuracy)
 {
     cv::Mat magnitude = randomMat(size, CV_32FC1);
     cv::Mat angle = randomMat(size, CV_32FC1);
@@ -2848,7 +2855,7 @@ PARAM_TEST_CASE(MeanStdDev, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(MeanStdDev, Accuracy)
+GPU_TEST_P(MeanStdDev, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_8UC1);
 
@@ -2908,7 +2915,7 @@ PARAM_TEST_CASE(Norm, cv::gpu::DeviceInfo, cv::Size, MatDepth, NormCode, UseRoi)
     }
 };
 
-TEST_P(Norm, Accuracy)
+GPU_TEST_P(Norm, Accuracy)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -2952,7 +2959,7 @@ PARAM_TEST_CASE(NormDiff, cv::gpu::DeviceInfo, cv::Size, NormCode, UseRoi)
     }
 };
 
-TEST_P(NormDiff, Accuracy)
+GPU_TEST_P(NormDiff, Accuracy)
 {
     cv::Mat src1 = randomMat(size, CV_8UC1);
     cv::Mat src2 = randomMat(size, CV_8UC1);
@@ -2973,81 +2980,84 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, NormDiff, testing::Combine(
 //////////////////////////////////////////////////////////////////////////////
 // Sum
 
-template <typename T>
-cv::Scalar absSumImpl(const cv::Mat& src)
+namespace
 {
-    const int cn = src.channels();
-
-    cv::Scalar sum = cv::Scalar::all(0);
-
-    for (int y = 0; y < src.rows; ++y)
+    template <typename T>
+    cv::Scalar absSumImpl(const cv::Mat& src)
     {
-        for (int x = 0; x < src.cols; ++x)
+        const int cn = src.channels();
+
+        cv::Scalar sum = cv::Scalar::all(0);
+
+        for (int y = 0; y < src.rows; ++y)
         {
-            for (int c = 0; c < cn; ++c)
-                sum[c] += std::abs(src.at<T>(y, x * cn + c));
-        }
-    }
-
-    return sum;
-}
-
-cv::Scalar absSumGold(const cv::Mat& src)
-{
-    typedef cv::Scalar (*func_t)(const cv::Mat& src);
-
-    static const func_t funcs[] =
-    {
-        absSumImpl<uchar>,
-        absSumImpl<schar>,
-        absSumImpl<ushort>,
-        absSumImpl<short>,
-        absSumImpl<int>,
-        absSumImpl<float>,
-        absSumImpl<double>
-    };
-
-    return funcs[src.depth()](src);
-}
-
-template <typename T>
-cv::Scalar sqrSumImpl(const cv::Mat& src)
-{
-    const int cn = src.channels();
-
-    cv::Scalar sum = cv::Scalar::all(0);
-
-    for (int y = 0; y < src.rows; ++y)
-    {
-        for (int x = 0; x < src.cols; ++x)
-        {
-            for (int c = 0; c < cn; ++c)
+            for (int x = 0; x < src.cols; ++x)
             {
-                const T val = src.at<T>(y, x * cn + c);
-                sum[c] += val * val;
+                for (int c = 0; c < cn; ++c)
+                    sum[c] += std::abs(src.at<T>(y, x * cn + c));
             }
         }
+
+        return sum;
     }
 
-    return sum;
-}
-
-cv::Scalar sqrSumGold(const cv::Mat& src)
-{
-    typedef cv::Scalar (*func_t)(const cv::Mat& src);
-
-    static const func_t funcs[] =
+    cv::Scalar absSumGold(const cv::Mat& src)
     {
-        sqrSumImpl<uchar>,
-        sqrSumImpl<schar>,
-        sqrSumImpl<ushort>,
-        sqrSumImpl<short>,
-        sqrSumImpl<int>,
-        sqrSumImpl<float>,
-        sqrSumImpl<double>
-    };
+        typedef cv::Scalar (*func_t)(const cv::Mat& src);
 
-    return funcs[src.depth()](src);
+        static const func_t funcs[] =
+        {
+            absSumImpl<uchar>,
+            absSumImpl<schar>,
+            absSumImpl<ushort>,
+            absSumImpl<short>,
+            absSumImpl<int>,
+            absSumImpl<float>,
+            absSumImpl<double>
+        };
+
+        return funcs[src.depth()](src);
+    }
+
+    template <typename T>
+    cv::Scalar sqrSumImpl(const cv::Mat& src)
+    {
+        const int cn = src.channels();
+
+        cv::Scalar sum = cv::Scalar::all(0);
+
+        for (int y = 0; y < src.rows; ++y)
+        {
+            for (int x = 0; x < src.cols; ++x)
+            {
+                for (int c = 0; c < cn; ++c)
+                {
+                    const T val = src.at<T>(y, x * cn + c);
+                    sum[c] += val * val;
+                }
+            }
+        }
+
+        return sum;
+    }
+
+    cv::Scalar sqrSumGold(const cv::Mat& src)
+    {
+        typedef cv::Scalar (*func_t)(const cv::Mat& src);
+
+        static const func_t funcs[] =
+        {
+            sqrSumImpl<uchar>,
+            sqrSumImpl<schar>,
+            sqrSumImpl<ushort>,
+            sqrSumImpl<short>,
+            sqrSumImpl<int>,
+            sqrSumImpl<float>,
+            sqrSumImpl<double>
+        };
+
+        return funcs[src.depth()](src);
+    }
 }
 
 PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
@@ -3072,7 +3082,7 @@ PARAM_TEST_CASE(Sum, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(Sum, Simple)
+GPU_TEST_P(Sum, Simple)
 {
     cv::Scalar val = cv::gpu::sum(loadMat(src, useRoi));
 
@@ -3081,7 +3091,7 @@ TEST_P(Sum, Simple)
     EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
-TEST_P(Sum, Abs)
+GPU_TEST_P(Sum, Abs)
 {
     cv::Scalar val = cv::gpu::absSum(loadMat(src, useRoi));
 
@@ -3090,7 +3100,7 @@ TEST_P(Sum, Abs)
     EXPECT_SCALAR_NEAR(val_gold, val, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.5);
 }
 
-TEST_P(Sum, Sqr)
+GPU_TEST_P(Sum, Sqr)
 {
     cv::Scalar val = cv::gpu::sqrSum(loadMat(src, useRoi));
 
@@ -3126,7 +3136,7 @@ PARAM_TEST_CASE(MinMax, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(MinMax, WithoutMask)
+GPU_TEST_P(MinMax, WithoutMask)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -3155,7 +3165,7 @@ TEST_P(MinMax, WithoutMask)
     }
 }
 
-TEST_P(MinMax, WithMask)
+GPU_TEST_P(MinMax, WithMask)
 {
     cv::Mat src = randomMat(size, depth);
     cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@@ -3185,7 +3195,7 @@ TEST_P(MinMax, WithMask)
     }
 }
 
-TEST_P(MinMax, NullPtr)
+GPU_TEST_P(MinMax, NullPtr)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -3225,28 +3235,31 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, MinMax, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////////
 // MinMaxLoc
 
-template <typename T>
-void expectEqualImpl(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
+namespace
 {
-    EXPECT_EQ(src.at<T>(loc_gold.y, loc_gold.x), src.at<T>(loc.y, loc.x));
-}
-
-void expectEqual(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
-{
-    typedef void (*func_t)(const cv::Mat& src, cv::Point loc_gold, cv::Point loc);
-
-    static const func_t funcs[] =
+    template <typename T>
+    void expectEqualImpl(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
     {
-        expectEqualImpl<uchar>,
-        expectEqualImpl<schar>,
-        expectEqualImpl<ushort>,
-        expectEqualImpl<short>,
-        expectEqualImpl<int>,
-        expectEqualImpl<float>,
-        expectEqualImpl<double>
-    };
+        EXPECT_EQ(src.at<T>(loc_gold.y, loc_gold.x), src.at<T>(loc.y, loc.x));
+    }
 
-    funcs[src.depth()](src, loc_gold, loc);
+    void expectEqual(const cv::Mat& src, cv::Point loc_gold, cv::Point loc)
+    {
+        typedef void (*func_t)(const cv::Mat& src, cv::Point loc_gold, cv::Point loc);
+
+        static const func_t funcs[] =
+        {
+            expectEqualImpl<uchar>,
+            expectEqualImpl<schar>,
+            expectEqualImpl<ushort>,
+            expectEqualImpl<short>,
+            expectEqualImpl<int>,
+            expectEqualImpl<float>,
+            expectEqualImpl<double>
+        };
+
+        funcs[src.depth()](src, loc_gold, loc);
+    }
 }
 
 PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
@@ -3267,7 +3280,7 @@ PARAM_TEST_CASE(MinMaxLoc, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(MinMaxLoc, WithoutMask)
+GPU_TEST_P(MinMaxLoc, WithoutMask)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -3302,7 +3315,7 @@ TEST_P(MinMaxLoc, WithoutMask)
     }
 }
 
-TEST_P(MinMaxLoc, WithMask)
+GPU_TEST_P(MinMaxLoc, WithMask)
 {
     cv::Mat src = randomMat(size, depth);
     cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@@ -3338,7 +3351,7 @@ TEST_P(MinMaxLoc, WithMask)
     }
 }
 
-TEST_P(MinMaxLoc, NullPtr)
+GPU_TEST_P(MinMaxLoc, NullPtr)
 {
     cv::Mat src = randomMat(size, depth);
 
@@ -3407,7 +3420,7 @@ PARAM_TEST_CASE(CountNonZero, cv::gpu::DeviceInfo, cv::Size, MatDepth, UseRoi)
     }
 };
 
-TEST_P(CountNonZero, Accuracy)
+GPU_TEST_P(CountNonZero, Accuracy)
 {
     cv::Mat srcBase = randomMat(size, CV_8U, 0.0, 1.5);
     cv::Mat src;
@@ -3484,7 +3497,7 @@ PARAM_TEST_CASE(Reduce, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Reduc
 
 };
 
-TEST_P(Reduce, Rows)
+GPU_TEST_P(Reduce, Rows)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -3497,7 +3510,7 @@ TEST_P(Reduce, Rows)
     EXPECT_MAT_NEAR(dst_gold, dst, dst_depth < CV_32F ? 0.0 : 0.02);
 }
 
-TEST_P(Reduce, Cols)
+GPU_TEST_P(Reduce, Cols)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -3525,6 +3538,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Core, Reduce, testing::Combine(
     ALL_REDUCE_CODES,
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_denoising.cpp b/modules/gpu/test/test_denoising.cpp
index 80bf3dbe2..fe0c548c7 100644
--- a/modules/gpu/test/test_denoising.cpp
+++ b/modules/gpu/test/test_denoising.cpp
@@ -69,7 +69,7 @@ PARAM_TEST_CASE(BilateralFilter, cv::gpu::DeviceInfo, cv::Size, MatType)
     }
 };
 
-TEST_P(BilateralFilter, Accuracy)
+GPU_TEST_P(BilateralFilter, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -105,7 +105,7 @@ struct BruteForceNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(BruteForceNonLocalMeans, Regression)
+GPU_TEST_P(BruteForceNonLocalMeans, Regression)
 {
     using cv::gpu::GpuMat;
 
@@ -134,8 +134,6 @@ TEST_P(BruteForceNonLocalMeans, Regression)
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, BruteForceNonLocalMeans, ALL_DEVICES);
 
-
-
 ////////////////////////////////////////////////////////
 // Fast Force Non local means
 
@@ -150,7 +148,7 @@ struct FastNonLocalMeans: testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(FastNonLocalMeans, Regression)
+GPU_TEST_P(FastNonLocalMeans, Regression)
 {
     using cv::gpu::GpuMat;
 
@@ -167,8 +165,8 @@ TEST_P(FastNonLocalMeans, Regression)
     fnlmd.labMethod(GpuMat(bgr),  dbgr, 20, 10);
 
 #if 0
-    //dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
-    //dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
+    dumpImage("denoising/fnlm_denoised_lena_bgr.png", cv::Mat(dbgr));
+    dumpImage("denoising/fnlm_denoised_lena_gray.png", cv::Mat(dgray));
 #endif
 
     cv::Mat bgr_gold  = readImage("denoising/fnlm_denoised_lena_bgr.png", cv::IMREAD_COLOR);
@@ -181,5 +179,4 @@ TEST_P(FastNonLocalMeans, Regression)
 
 INSTANTIATE_TEST_CASE_P(GPU_Denoising, FastNonLocalMeans, ALL_DEVICES);
 
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_features2d.cpp b/modules/gpu/test/test_features2d.cpp
index c76fe9166..3879ac053 100644
--- a/modules/gpu/test/test_features2d.cpp
+++ b/modules/gpu/test/test_features2d.cpp
@@ -43,118 +43,122 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
-bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
+namespace
 {
-    const double maxPtDif = 1.0;
-    const double maxSizeDif = 1.0;
-    const double maxAngleDif = 2.0;
-    const double maxResponseDif = 0.1;
-
-    double dist = cv::norm(p1.pt - p2.pt);
-
-    if (dist < maxPtDif &&
-        fabs(p1.size - p2.size) < maxSizeDif &&
-        abs(p1.angle - p2.angle) < maxAngleDif &&
-        abs(p1.response - p2.response) < maxResponseDif &&
-        p1.octave == p2.octave &&
-        p1.class_id == p2.class_id)
+    bool keyPointsEquals(const cv::KeyPoint& p1, const cv::KeyPoint& p2)
     {
-        return true;
-    }
+        const double maxPtDif = 1.0;
+        const double maxSizeDif = 1.0;
+        const double maxAngleDif = 2.0;
+        const double maxResponseDif = 0.1;
 
-    return false;
-}
+        double dist = cv::norm(p1.pt - p2.pt);
 
-struct KeyPointLess : std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
-{
-    bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
-    {
-        return kp1.pt.y < kp2.pt.y || (kp1.pt.y == kp2.pt.y && kp1.pt.x < kp2.pt.x);
-    }
-};
-
-testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
-{
-    if (gold.size() != actual.size())
-    {
-        return testing::AssertionFailure() << "KeyPoints size mistmach\n"
-                                           << "\"" << gold_expr << "\" : " << gold.size() << "\n"
-                                           << "\"" << actual_expr << "\" : " << actual.size();
-    }
-
-    std::sort(actual.begin(), actual.end(), KeyPointLess());
-    std::sort(gold.begin(), gold.end(), KeyPointLess());
-
-    for (size_t i = 0; i < gold.size(); ++i)
-    {
-        const cv::KeyPoint& p1 = gold[i];
-        const cv::KeyPoint& p2 = actual[i];
-
-        if (!keyPointsEquals(p1, p2))
+        if (dist < maxPtDif &&
+            fabs(p1.size - p2.size) < maxSizeDif &&
+            abs(p1.angle - p2.angle) < maxAngleDif &&
+            abs(p1.response - p2.response) < maxResponseDif &&
+            p1.octave == p2.octave &&
+            p1.class_id == p2.class_id)
         {
-            return testing::AssertionFailure() << "KeyPoints differ at " << i << "\n"
-                                               << "\"" << gold_expr << "\" vs \"" << actual_expr << "\" : \n"
-                                               << "pt : " << testing::PrintToString(p1.pt) << " vs " << testing::PrintToString(p2.pt) << "\n"
-                                               << "size : " << p1.size << " vs " << p2.size << "\n"
-                                               << "angle : " << p1.angle << " vs " << p2.angle << "\n"
-                                               << "response : " << p1.response << " vs " << p2.response << "\n"
-                                               << "octave : " << p1.octave << " vs " << p2.octave << "\n"
-                                               << "class_id : " << p1.class_id << " vs " << p2.class_id;
+            return true;
         }
+
+        return false;
     }
 
-    return ::testing::AssertionSuccess();
-}
-
-#define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual);
-
-int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
-{
-    std::sort(actual.begin(), actual.end(), KeyPointLess());
-    std::sort(gold.begin(), gold.end(), KeyPointLess());
-
-    int validCount = 0;
-
-    for (size_t i = 0; i < gold.size(); ++i)
+    struct KeyPointLess : std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
     {
-        const cv::KeyPoint& p1 = gold[i];
-        const cv::KeyPoint& p2 = actual[i];
+        bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
+        {
+            return kp1.pt.y < kp2.pt.y || (kp1.pt.y == kp2.pt.y && kp1.pt.x < kp2.pt.x);
+        }
+    };
 
-        if (keyPointsEquals(p1, p2))
-            ++validCount;
-    }
-
-    return validCount;
-}
-
-int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches)
-{
-    int validCount = 0;
-
-    for (size_t i = 0; i < matches.size(); ++i)
+    testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
     {
-        const cv::DMatch& m = matches[i];
+        if (gold.size() != actual.size())
+        {
+            return testing::AssertionFailure() << "KeyPoints size mistmach\n"
+                                               << "\"" << gold_expr << "\" : " << gold.size() << "\n"
+                                               << "\"" << actual_expr << "\" : " << actual.size();
+        }
 
-        const cv::KeyPoint& p1 = keypoints1[m.queryIdx];
-        const cv::KeyPoint& p2 = keypoints2[m.trainIdx];
+        std::sort(actual.begin(), actual.end(), KeyPointLess());
+        std::sort(gold.begin(), gold.end(), KeyPointLess());
 
-        if (keyPointsEquals(p1, p2))
-            ++validCount;
+        for (size_t i = 0; i < gold.size(); ++i)
+        {
+            const cv::KeyPoint& p1 = gold[i];
+            const cv::KeyPoint& p2 = actual[i];
+
+            if (!keyPointsEquals(p1, p2))
+            {
+                return testing::AssertionFailure() << "KeyPoints differ at " << i << "\n"
+                                                   << "\"" << gold_expr << "\" vs \"" << actual_expr << "\" : \n"
+                                                   << "pt : " << testing::PrintToString(p1.pt) << " vs " << testing::PrintToString(p2.pt) << "\n"
+                                                   << "size : " << p1.size << " vs " << p2.size << "\n"
+                                                   << "angle : " << p1.angle << " vs " << p2.angle << "\n"
+                                                   << "response : " << p1.response << " vs " << p2.response << "\n"
+                                                   << "octave : " << p1.octave << " vs " << p2.octave << "\n"
+                                                   << "class_id : " << p1.class_id << " vs " << p2.class_id;
+            }
+        }
+
+        return ::testing::AssertionSuccess();
     }
 
-    return validCount;
+    #define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual);
+
+    int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual)
+    {
+        std::sort(actual.begin(), actual.end(), KeyPointLess());
+        std::sort(gold.begin(), gold.end(), KeyPointLess());
+
+        int validCount = 0;
+
+        for (size_t i = 0; i < gold.size(); ++i)
+        {
+            const cv::KeyPoint& p1 = gold[i];
+            const cv::KeyPoint& p2 = actual[i];
+
+            if (keyPointsEquals(p1, p2))
+                ++validCount;
+        }
+
+        return validCount;
+    }
+
+    int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches)
+    {
+        int validCount = 0;
+
+        for (size_t i = 0; i < matches.size(); ++i)
+        {
+            const cv::DMatch& m = matches[i];
+
+            const cv::KeyPoint& p1 = keypoints1[m.queryIdx];
+            const cv::KeyPoint& p2 = keypoints2[m.trainIdx];
+
+            if (keyPointsEquals(p1, p2))
+                ++validCount;
+        }
+
+        return validCount;
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // SURF
 
-IMPLEMENT_PARAM_CLASS(SURF_HessianThreshold, double)
-IMPLEMENT_PARAM_CLASS(SURF_Octaves, int)
-IMPLEMENT_PARAM_CLASS(SURF_OctaveLayers, int)
-IMPLEMENT_PARAM_CLASS(SURF_Extended, bool)
-IMPLEMENT_PARAM_CLASS(SURF_Upright, bool)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(SURF_HessianThreshold, double)
+    IMPLEMENT_PARAM_CLASS(SURF_Octaves, int)
+    IMPLEMENT_PARAM_CLASS(SURF_OctaveLayers, int)
+    IMPLEMENT_PARAM_CLASS(SURF_Extended, bool)
+    IMPLEMENT_PARAM_CLASS(SURF_Upright, bool)
+}
 
 PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves, SURF_OctaveLayers, SURF_Extended, SURF_Upright)
 {
@@ -178,7 +182,7 @@ PARAM_TEST_CASE(SURF, cv::gpu::DeviceInfo, SURF_HessianThreshold, SURF_Octaves,
     }
 };
 
-TEST_P(SURF, Detector)
+GPU_TEST_P(SURF, Detector)
 {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
@@ -226,7 +230,7 @@ TEST_P(SURF, Detector)
     }
 }
 
-TEST_P(SURF, Detector_Masked)
+GPU_TEST_P(SURF, Detector_Masked)
 {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
@@ -277,7 +281,7 @@ TEST_P(SURF, Detector_Masked)
     }
 }
 
-TEST_P(SURF, Descriptor)
+GPU_TEST_P(SURF, Descriptor)
 {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
@@ -343,8 +347,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, SURF, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // FAST
 
-IMPLEMENT_PARAM_CLASS(FAST_Threshold, int)
-IMPLEMENT_PARAM_CLASS(FAST_NonmaxSupression, bool)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(FAST_Threshold, int)
+    IMPLEMENT_PARAM_CLASS(FAST_NonmaxSupression, bool)
+}
 
 PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression)
 {
@@ -362,7 +369,7 @@ PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression
     }
 };
 
-TEST_P(FAST, Accuracy)
+GPU_TEST_P(FAST, Accuracy)
 {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
@@ -402,14 +409,17 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // ORB
 
-IMPLEMENT_PARAM_CLASS(ORB_FeaturesCount, int)
-IMPLEMENT_PARAM_CLASS(ORB_ScaleFactor, float)
-IMPLEMENT_PARAM_CLASS(ORB_LevelsCount, int)
-IMPLEMENT_PARAM_CLASS(ORB_EdgeThreshold, int)
-IMPLEMENT_PARAM_CLASS(ORB_firstLevel, int)
-IMPLEMENT_PARAM_CLASS(ORB_WTA_K, int)
-IMPLEMENT_PARAM_CLASS(ORB_PatchSize, int)
-IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(ORB_FeaturesCount, int)
+    IMPLEMENT_PARAM_CLASS(ORB_ScaleFactor, float)
+    IMPLEMENT_PARAM_CLASS(ORB_LevelsCount, int)
+    IMPLEMENT_PARAM_CLASS(ORB_EdgeThreshold, int)
+    IMPLEMENT_PARAM_CLASS(ORB_firstLevel, int)
+    IMPLEMENT_PARAM_CLASS(ORB_WTA_K, int)
+    IMPLEMENT_PARAM_CLASS(ORB_PatchSize, int)
+    IMPLEMENT_PARAM_CLASS(ORB_BlurForDescriptor, bool)
+}
 
 CV_ENUM(ORB_ScoreType, cv::ORB::HARRIS_SCORE, cv::ORB::FAST_SCORE)
 
@@ -443,7 +453,7 @@ PARAM_TEST_CASE(ORB, cv::gpu::DeviceInfo, ORB_FeaturesCount, ORB_ScaleFactor, OR
     }
 };
 
-TEST_P(ORB, Accuracy)
+GPU_TEST_P(ORB, Accuracy)
 {
     cv::Mat image = readImage("features2d/aloe.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(image.empty());
@@ -505,8 +515,11 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, ORB,  testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // BruteForceMatcher
 
-IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
-IMPLEMENT_PARAM_CLASS(UseMask, bool)
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(DescriptorSize, int)
+    IMPLEMENT_PARAM_CLASS(UseMask, bool)
+}
 
 PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize, UseMask)
 {
@@ -568,7 +581,7 @@ PARAM_TEST_CASE(BruteForceMatcher, cv::gpu::DeviceInfo, NormCode, DescriptorSize
     }
 };
 
-TEST_P(BruteForceMatcher, Match_Single)
+GPU_TEST_P(BruteForceMatcher, Match_Single)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -595,7 +608,7 @@ TEST_P(BruteForceMatcher, Match_Single)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, Match_Collection)
+GPU_TEST_P(BruteForceMatcher, Match_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -649,7 +662,7 @@ TEST_P(BruteForceMatcher, Match_Collection)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, KnnMatch_2_Single)
+GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Single)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -688,7 +701,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Single)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, KnnMatch_3_Single)
+GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Single)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -727,7 +740,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Single)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
+GPU_TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -789,7 +802,7 @@ TEST_P(BruteForceMatcher, KnnMatch_2_Collection)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
+GPU_TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -851,7 +864,7 @@ TEST_P(BruteForceMatcher, KnnMatch_3_Collection)
     ASSERT_EQ(0, badCount);
 }
 
-TEST_P(BruteForceMatcher, RadiusMatch_Single)
+GPU_TEST_P(BruteForceMatcher, RadiusMatch_Single)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -900,7 +913,7 @@ TEST_P(BruteForceMatcher, RadiusMatch_Single)
     }
 }
 
-TEST_P(BruteForceMatcher, RadiusMatch_Collection)
+GPU_TEST_P(BruteForceMatcher, RadiusMatch_Collection)
 {
     cv::gpu::BFMatcher_GPU matcher(normCode);
 
@@ -985,6 +998,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Features2D, BruteForceMatcher, testing::Combine(
     testing::Values(DescriptorSize(57), DescriptorSize(64), DescriptorSize(83), DescriptorSize(128), DescriptorSize(179), DescriptorSize(256), DescriptorSize(304)),
     testing::Values(UseMask(false), UseMask(true))));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 92d6fc002..779a6d7c4 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -43,27 +43,30 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
-IMPLEMENT_PARAM_CLASS(KSize, cv::Size)
-
-cv::Mat getInnerROI(cv::InputArray m_, cv::Size ksize)
+namespace
 {
-    cv::Mat m = getMat(m_);
-    cv::Rect roi(ksize.width, ksize.height, m.cols - 2 * ksize.width, m.rows - 2 * ksize.height);
-    return m(roi);
-}
+    IMPLEMENT_PARAM_CLASS(KSize, cv::Size)
+    IMPLEMENT_PARAM_CLASS(Anchor, cv::Point)
+    IMPLEMENT_PARAM_CLASS(Deriv_X, int)
+    IMPLEMENT_PARAM_CLASS(Deriv_Y, int)
+    IMPLEMENT_PARAM_CLASS(Iterations, int)
 
-cv::Mat getInnerROI(cv::InputArray m, int ksize)
-{
-    return getInnerROI(m, cv::Size(ksize, ksize));
+    cv::Mat getInnerROI(cv::InputArray m_, cv::Size ksize)
+    {
+        cv::Mat m = getMat(m_);
+        cv::Rect roi(ksize.width, ksize.height, m.cols - 2 * ksize.width, m.rows - 2 * ksize.height);
+        return m(roi);
+    }
+
+    cv::Mat getInnerROI(cv::InputArray m, int ksize)
+    {
+        return getInnerROI(m, cv::Size(ksize, ksize));
+    }
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Blur
 
-IMPLEMENT_PARAM_CLASS(Anchor, cv::Point)
-
 PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -86,7 +89,7 @@ PARAM_TEST_CASE(Blur, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor, Use
     }
 };
 
-TEST_P(Blur, Accuracy)
+GPU_TEST_P(Blur, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -110,9 +113,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Blur, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Sobel
 
-IMPLEMENT_PARAM_CLASS(Deriv_X, int)
-IMPLEMENT_PARAM_CLASS(Deriv_Y, int)
-
 PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize, Deriv_X, Deriv_Y, BorderType, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -145,7 +145,7 @@ PARAM_TEST_CASE(Sobel, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, KSize,
     }
 };
 
-TEST_P(Sobel, Accuracy)
+GPU_TEST_P(Sobel, Accuracy)
 {
     if (dx == 0 && dy == 0)
         return;
@@ -208,7 +208,7 @@ PARAM_TEST_CASE(Scharr, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, Deriv
     }
 };
 
-TEST_P(Scharr, Accuracy)
+GPU_TEST_P(Scharr, Accuracy)
 {
     if (dx + dy != 1)
         return;
@@ -268,7 +268,7 @@ PARAM_TEST_CASE(GaussianBlur, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels,
     }
 };
 
-TEST_P(GaussianBlur, Accuracy)
+GPU_TEST_P(GaussianBlur, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     double sigma1 = randomDouble(0.1, 1.0);
@@ -347,7 +347,7 @@ PARAM_TEST_CASE(Laplacian, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, UseRoi
     }
 };
 
-TEST_P(Laplacian, Accuracy)
+GPU_TEST_P(Laplacian, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -370,8 +370,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Laplacian, testing::Combine(
 /////////////////////////////////////////////////////////////////////////////////////////////////
 // Erode
 
-IMPLEMENT_PARAM_CLASS(Iterations, int)
-
 PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iterations, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -394,7 +392,7 @@ PARAM_TEST_CASE(Erode, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteration
     }
 };
 
-TEST_P(Erode, Accuracy)
+GPU_TEST_P(Erode, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@@ -443,7 +441,7 @@ PARAM_TEST_CASE(Dilate, cv::gpu::DeviceInfo, cv::Size, MatType, Anchor, Iteratio
     }
 };
 
-TEST_P(Dilate, Accuracy)
+GPU_TEST_P(Dilate, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@@ -497,7 +495,7 @@ PARAM_TEST_CASE(MorphEx, cv::gpu::DeviceInfo, cv::Size, MatType, MorphOp, Anchor
     }
 };
 
-TEST_P(MorphEx, Accuracy)
+GPU_TEST_P(MorphEx, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = cv::Mat::ones(3, 3, CV_8U);
@@ -551,7 +549,7 @@ PARAM_TEST_CASE(Filter2D, cv::gpu::DeviceInfo, cv::Size, MatType, KSize, Anchor,
     }
 };
 
-TEST_P(Filter2D, Accuracy)
+GPU_TEST_P(Filter2D, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat kernel = randomMat(cv::Size(ksize.width, ksize.height), CV_32FC1, 0.0, 1.0);
@@ -574,6 +572,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Filter, Filter2D, testing::Combine(
     testing::Values(BorderType(cv::BORDER_REFLECT101), BorderType(cv::BORDER_REPLICATE), BorderType(cv::BORDER_CONSTANT), BorderType(cv::BORDER_REFLECT)),
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_global_motion.cpp b/modules/gpu/test/test_global_motion.cpp
index b37d08068..48fc428ce 100644
--- a/modules/gpu/test/test_global_motion.cpp
+++ b/modules/gpu/test/test_global_motion.cpp
@@ -51,7 +51,7 @@ struct CompactPoints : testing::TestWithParam<gpu::DeviceInfo>
     virtual void SetUp() { gpu::setDevice(GetParam().deviceID()); }
 };
 
-TEST_P(CompactPoints, CanCompactizeSmallInput)
+GPU_TEST_P(CompactPoints, CanCompactizeSmallInput)
 {
     Mat src0(1, 3, CV_32FC2);
     src0.at<Point2f>(0,0) = Point2f(0,0);
diff --git a/modules/gpu/test/test_gpumat.cpp b/modules/gpu/test/test_gpumat.cpp
index 9d7e545de..9ece87caa 100644
--- a/modules/gpu/test/test_gpumat.cpp
+++ b/modules/gpu/test/test_gpumat.cpp
@@ -44,8 +44,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 ////////////////////////////////////////////////////////////////////////////////
 // SetTo
 
@@ -67,7 +65,7 @@ PARAM_TEST_CASE(SetTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(SetTo, Zero)
+GPU_TEST_P(SetTo, Zero)
 {
     cv::Scalar zero = cv::Scalar::all(0);
 
@@ -77,7 +75,7 @@ TEST_P(SetTo, Zero)
     EXPECT_MAT_NEAR(cv::Mat::zeros(size, type), mat, 0.0);
 }
 
-TEST_P(SetTo, SameVal)
+GPU_TEST_P(SetTo, SameVal)
 {
     cv::Scalar val = cv::Scalar::all(randomDouble(0.0, 255.0));
 
@@ -102,7 +100,7 @@ TEST_P(SetTo, SameVal)
     }
 }
 
-TEST_P(SetTo, DifferentVal)
+GPU_TEST_P(SetTo, DifferentVal)
 {
     cv::Scalar val = randomScalar(0.0, 255.0);
 
@@ -127,7 +125,7 @@ TEST_P(SetTo, DifferentVal)
     }
 }
 
-TEST_P(SetTo, Masked)
+GPU_TEST_P(SetTo, Masked)
 {
     cv::Scalar val = randomScalar(0.0, 255.0);
     cv::Mat mat_gold = randomMat(size, type);
@@ -184,7 +182,7 @@ PARAM_TEST_CASE(CopyTo, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(CopyTo, WithOutMask)
+GPU_TEST_P(CopyTo, WithOutMask)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -195,7 +193,7 @@ TEST_P(CopyTo, WithOutMask)
     EXPECT_MAT_NEAR(src, dst, 0.0);
 }
 
-TEST_P(CopyTo, Masked)
+GPU_TEST_P(CopyTo, Masked)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat mask = randomMat(size, CV_8UC1, 0.0, 2.0);
@@ -255,7 +253,7 @@ PARAM_TEST_CASE(ConvertTo, cv::gpu::DeviceInfo, cv::Size, MatDepth, MatDepth, Us
     }
 };
 
-TEST_P(ConvertTo, WithOutScaling)
+GPU_TEST_P(ConvertTo, WithOutScaling)
 {
     cv::Mat src = randomMat(size, depth1);
 
@@ -285,7 +283,7 @@ TEST_P(ConvertTo, WithOutScaling)
     }
 }
 
-TEST_P(ConvertTo, WithScaling)
+GPU_TEST_P(ConvertTo, WithScaling)
 {
     cv::Mat src = randomMat(size, depth1);
     double a = randomDouble(0.0, 1.0);
@@ -336,7 +334,7 @@ struct EnsureSizeIsEnough : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(EnsureSizeIsEnough, BufferReuse)
+GPU_TEST_P(EnsureSizeIsEnough, BufferReuse)
 {
     cv::gpu::GpuMat buffer(100, 100, CV_8U);
     cv::gpu::GpuMat old = buffer;
@@ -358,6 +356,4 @@ TEST_P(EnsureSizeIsEnough, BufferReuse)
 
 INSTANTIATE_TEST_CASE_P(GPU_GpuMat, EnsureSizeIsEnough, ALL_DEVICES);
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_hough.cpp b/modules/gpu/test/test_hough.cpp
index c418d6ad7..9044e5b0d 100644
--- a/modules/gpu/test/test_hough.cpp
+++ b/modules/gpu/test/test_hough.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // HoughLines
 
@@ -79,7 +77,7 @@ PARAM_TEST_CASE(HoughLines, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(HoughLines, Accuracy)
+GPU_TEST_P(HoughLines, Accuracy)
 {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
@@ -88,7 +86,7 @@ TEST_P(HoughLines, Accuracy)
 
     const float rho = 1.0f;
     const float theta = (float) (1.5 * CV_PI / 180.0);
-    onst int threshold = 100;
+    const int threshold = 100;
 
     cv::Mat src(size, CV_8UC1);
     generateLines(src);
@@ -124,7 +122,7 @@ PARAM_TEST_CASE(HoughCircles, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(HoughCircles, Accuracy)
+GPU_TEST_P(HoughCircles, Accuracy)
 {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
@@ -188,7 +186,7 @@ PARAM_TEST_CASE(GeneralizedHough, cv::gpu::DeviceInfo, UseRoi)
 {
 };
 
-TEST_P(GeneralizedHough, POSITION)
+GPU_TEST_P(GeneralizedHough, POSITION)
 {
     const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
     cv::gpu::setDevice(devInfo.deviceID());
@@ -251,6 +249,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, GeneralizedHough, testing::Combine(
     ALL_DEVICES,
     WHOLE_SUBMAT));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_imgproc.cpp b/modules/gpu/test/test_imgproc.cpp
index 71d4a8e65..41a94299b 100644
--- a/modules/gpu/test/test_imgproc.cpp
+++ b/modules/gpu/test/test_imgproc.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // Integral
 
@@ -64,7 +62,7 @@ PARAM_TEST_CASE(Integral, cv::gpu::DeviceInfo, cv::Size, UseRoi)
     }
 };
 
-TEST_P(Integral, Accuracy)
+GPU_TEST_P(Integral, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_8UC1);
 
@@ -97,7 +95,7 @@ struct HistEven : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(HistEven, Accuracy)
+GPU_TEST_P(HistEven, Accuracy)
 {
     cv::Mat img = readImage("stereobm/aloe-L.png");
     ASSERT_FALSE(img.empty());
@@ -132,18 +130,21 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, HistEven, ALL_DEVICES);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // CalcHist
 
-void calcHistGold(const cv::Mat& src, cv::Mat& hist)
+namespace
 {
-    hist.create(1, 256, CV_32SC1);
-    hist.setTo(cv::Scalar::all(0));
-
-    int* hist_row = hist.ptr<int>();
-    for (int y = 0; y < src.rows; ++y)
+    void calcHistGold(const cv::Mat& src, cv::Mat& hist)
     {
-        const uchar* src_row = src.ptr(y);
+        hist.create(1, 256, CV_32SC1);
+        hist.setTo(cv::Scalar::all(0));
 
-        for (int x = 0; x < src.cols; ++x)
-            ++hist_row[src_row[x]];
+        int* hist_row = hist.ptr<int>();
+        for (int y = 0; y < src.rows; ++y)
+        {
+            const uchar* src_row = src.ptr(y);
+
+            for (int x = 0; x < src.cols; ++x)
+                ++hist_row[src_row[x]];
+        }
     }
 }
 
@@ -162,7 +163,7 @@ PARAM_TEST_CASE(CalcHist, cv::gpu::DeviceInfo, cv::Size)
     }
 };
 
-TEST_P(CalcHist, Accuracy)
+GPU_TEST_P(CalcHist, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_8UC1);
 
@@ -196,7 +197,7 @@ PARAM_TEST_CASE(EqualizeHist, cv::gpu::DeviceInfo, cv::Size)
     }
 };
 
-TEST_P(EqualizeHist, Accuracy)
+GPU_TEST_P(EqualizeHist, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_8UC1);
 
@@ -230,7 +231,7 @@ PARAM_TEST_CASE(ColumnSum, cv::gpu::DeviceInfo, cv::Size)
     }
 };
 
-TEST_P(ColumnSum, Accuracy)
+GPU_TEST_P(ColumnSum, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_32FC1);
 
@@ -264,8 +265,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, ColumnSum, testing::Combine(
 ////////////////////////////////////////////////////////
 // Canny
 
-IMPLEMENT_PARAM_CLASS(AppertureSize, int);
-IMPLEMENT_PARAM_CLASS(L2gradient, bool);
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(AppertureSize, int);
+    IMPLEMENT_PARAM_CLASS(L2gradient, bool);
+}
 
 PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
 {
@@ -285,7 +289,7 @@ PARAM_TEST_CASE(Canny, cv::gpu::DeviceInfo, AppertureSize, L2gradient, UseRoi)
     }
 };
 
-TEST_P(Canny, Accuracy)
+GPU_TEST_P(Canny, Accuracy)
 {
     cv::Mat img = readImage("stereobm/aloe-L.png", cv::IMREAD_GRAYSCALE);
     ASSERT_FALSE(img.empty());
@@ -349,7 +353,7 @@ struct MeanShift : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(MeanShift, Filtering)
+GPU_TEST_P(MeanShift, Filtering)
 {
     cv::Mat img_template;
     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
@@ -371,7 +375,7 @@ TEST_P(MeanShift, Filtering)
     EXPECT_MAT_NEAR(img_template, result, 0.0);
 }
 
-TEST_P(MeanShift, Proc)
+GPU_TEST_P(MeanShift, Proc)
 {
     cv::FileStorage fs;
     if (supportFeature(devInfo, cv::gpu::FEATURE_SET_COMPUTE_20))
@@ -402,7 +406,10 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShift, ALL_DEVICES);
 ////////////////////////////////////////////////////////////////////////////////
 // MeanShiftSegmentation
 
-IMPLEMENT_PARAM_CLASS(MinSize, int);
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(MinSize, int);
+}
 
 PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
 {
@@ -418,7 +425,7 @@ PARAM_TEST_CASE(MeanShiftSegmentation, cv::gpu::DeviceInfo, MinSize)
     }
 };
 
-TEST_P(MeanShiftSegmentation, Regression)
+GPU_TEST_P(MeanShiftSegmentation, Regression)
 {
     cv::Mat img = readImageType("meanshift/cones.png", CV_8UC4);
     ASSERT_FALSE(img.empty());
@@ -448,26 +455,29 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, MeanShiftSegmentation, testing::Combine(
 ////////////////////////////////////////////////////////////////////////////
 // Blend
 
-template <typename T>
-void blendLinearGold(const cv::Mat& img1, const cv::Mat& img2, const cv::Mat& weights1, const cv::Mat& weights2, cv::Mat& result_gold)
+namespace
 {
-    result_gold.create(img1.size(), img1.type());
-
-    int cn = img1.channels();
-
-    for (int y = 0; y < img1.rows; ++y)
+    template <typename T>
+    void blendLinearGold(const cv::Mat& img1, const cv::Mat& img2, const cv::Mat& weights1, const cv::Mat& weights2, cv::Mat& result_gold)
     {
-        const float* weights1_row = weights1.ptr<float>(y);
-        const float* weights2_row = weights2.ptr<float>(y);
-        const T* img1_row = img1.ptr<T>(y);
-        const T* img2_row = img2.ptr<T>(y);
-        T* result_gold_row = result_gold.ptr<T>(y);
+        result_gold.create(img1.size(), img1.type());
 
-        for (int x = 0; x < img1.cols * cn; ++x)
+        int cn = img1.channels();
+
+        for (int y = 0; y < img1.rows; ++y)
         {
-            float w1 = weights1_row[x / cn];
-            float w2 = weights2_row[x / cn];
-            result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
+            const float* weights1_row = weights1.ptr<float>(y);
+            const float* weights2_row = weights2.ptr<float>(y);
+            const T* img1_row = img1.ptr<T>(y);
+            const T* img2_row = img2.ptr<T>(y);
+            T* result_gold_row = result_gold.ptr<T>(y);
+
+            for (int x = 0; x < img1.cols * cn; ++x)
+            {
+                float w1 = weights1_row[x / cn];
+                float w2 = weights2_row[x / cn];
+                result_gold_row[x] = static_cast<T>((img1_row[x] * w1 + img2_row[x] * w2) / (w1 + w2 + 1e-5f));
+            }
         }
     }
 }
@@ -490,7 +500,7 @@ PARAM_TEST_CASE(Blend, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(Blend, Accuracy)
+GPU_TEST_P(Blend, Accuracy)
 {
     int depth = CV_MAT_DEPTH(type);
 
@@ -520,48 +530,51 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Blend, testing::Combine(
 ////////////////////////////////////////////////////////
 // Convolve
 
-void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)
+namespace
 {
-    // reallocate the output array if needed
-    C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());
-    cv::Size dftSize;
+    void convolveDFT(const cv::Mat& A, const cv::Mat& B, cv::Mat& C, bool ccorr = false)
+    {
+        // reallocate the output array if needed
+        C.create(std::abs(A.rows - B.rows) + 1, std::abs(A.cols - B.cols) + 1, A.type());
+        cv::Size dftSize;
 
-    // compute the size of DFT transform
-    dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);
-    dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);
+        // compute the size of DFT transform
+        dftSize.width = cv::getOptimalDFTSize(A.cols + B.cols - 1);
+        dftSize.height = cv::getOptimalDFTSize(A.rows + B.rows - 1);
 
-    // allocate temporary buffers and initialize them with 0s
-    cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));
-    cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));
+        // allocate temporary buffers and initialize them with 0s
+        cv::Mat tempA(dftSize, A.type(), cv::Scalar::all(0));
+        cv::Mat tempB(dftSize, B.type(), cv::Scalar::all(0));
 
-    // copy A and B to the top-left corners of tempA and tempB, respectively
-    cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));
-    A.copyTo(roiA);
-    cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));
-    B.copyTo(roiB);
+        // copy A and B to the top-left corners of tempA and tempB, respectively
+        cv::Mat roiA(tempA, cv::Rect(0, 0, A.cols, A.rows));
+        A.copyTo(roiA);
+        cv::Mat roiB(tempB, cv::Rect(0, 0, B.cols, B.rows));
+        B.copyTo(roiB);
 
-    // now transform the padded A & B in-place;
-    // use "nonzeroRows" hint for faster processing
-    cv::dft(tempA, tempA, 0, A.rows);
-    cv::dft(tempB, tempB, 0, B.rows);
+        // now transform the padded A & B in-place;
+        // use "nonzeroRows" hint for faster processing
+        cv::dft(tempA, tempA, 0, A.rows);
+        cv::dft(tempB, tempB, 0, B.rows);
 
-    // multiply the spectrums;
-    // the function handles packed spectrum representations well
-    cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);
+        // multiply the spectrums;
+        // the function handles packed spectrum representations well
+        cv::mulSpectrums(tempA, tempB, tempA, 0, ccorr);
 
-    // transform the product back from the frequency domain.
-    // Even though all the result rows will be non-zero,
-    // you need only the first C.rows of them, and thus you
-    // pass nonzeroRows == C.rows
-    cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);
+        // transform the product back from the frequency domain.
+        // Even though all the result rows will be non-zero,
+        // you need only the first C.rows of them, and thus you
+        // pass nonzeroRows == C.rows
+        cv::dft(tempA, tempA, cv::DFT_INVERSE + cv::DFT_SCALE, C.rows);
 
-    // now copy the result back to C.
-    tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);
+        // now copy the result back to C.
+        tempA(cv::Rect(0, 0, C.cols, C.rows)).copyTo(C);
+    }
+
+    IMPLEMENT_PARAM_CLASS(KSize, int);
+    IMPLEMENT_PARAM_CLASS(Ccorr, bool);
 }
 
-IMPLEMENT_PARAM_CLASS(KSize, int);
-IMPLEMENT_PARAM_CLASS(Ccorr, bool);
-
 PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -580,7 +593,7 @@ PARAM_TEST_CASE(Convolve, cv::gpu::DeviceInfo, cv::Size, KSize, Ccorr)
     }
 };
 
-TEST_P(Convolve, Accuracy)
+GPU_TEST_P(Convolve, Accuracy)
 {
     cv::Mat src = randomMat(size, CV_32FC1, 0.0, 100.0);
     cv::Mat kernel = randomMat(cv::Size(ksize, ksize), CV_32FC1, 0.0, 1.0);
@@ -606,7 +619,10 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Convolve, testing::Combine(
 CV_ENUM(TemplateMethod, cv::TM_SQDIFF, cv::TM_SQDIFF_NORMED, cv::TM_CCORR, cv::TM_CCORR_NORMED, cv::TM_CCOEFF, cv::TM_CCOEFF_NORMED)
 #define ALL_TEMPLATE_METHODS testing::Values(TemplateMethod(cv::TM_SQDIFF), TemplateMethod(cv::TM_SQDIFF_NORMED), TemplateMethod(cv::TM_CCORR), TemplateMethod(cv::TM_CCORR_NORMED), TemplateMethod(cv::TM_CCOEFF), TemplateMethod(cv::TM_CCOEFF_NORMED))
 
-IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size);
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(TemplateSize, cv::Size);
+}
 
 PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Channels, TemplateMethod)
 {
@@ -628,7 +644,7 @@ PARAM_TEST_CASE(MatchTemplate8U, cv::gpu::DeviceInfo, cv::Size, TemplateSize, Ch
     }
 };
 
-TEST_P(MatchTemplate8U, Accuracy)
+GPU_TEST_P(MatchTemplate8U, Accuracy)
 {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_8U, cn));
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_8U, cn));
@@ -674,7 +690,7 @@ PARAM_TEST_CASE(MatchTemplate32F, cv::gpu::DeviceInfo, cv::Size, TemplateSize, C
     }
 };
 
-TEST_P(MatchTemplate32F, Regression)
+GPU_TEST_P(MatchTemplate32F, Regression)
 {
     cv::Mat image = randomMat(size, CV_MAKETYPE(CV_32F, cn));
     cv::Mat templ = randomMat(templ_size, CV_MAKETYPE(CV_32F, cn));
@@ -712,7 +728,7 @@ PARAM_TEST_CASE(MatchTemplateBlackSource, cv::gpu::DeviceInfo, TemplateMethod)
     }
 };
 
-TEST_P(MatchTemplateBlackSource, Accuracy)
+GPU_TEST_P(MatchTemplateBlackSource, Accuracy)
 {
     cv::Mat image = readImage("matchtemplate/black.png");
     ASSERT_FALSE(image.empty());
@@ -757,7 +773,7 @@ PARAM_TEST_CASE(MatchTemplate_CCOEF_NORMED, cv::gpu::DeviceInfo, std::pair<std::
     }
 };
 
-TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
+GPU_TEST_P(MatchTemplate_CCOEF_NORMED, Accuracy)
 {
     cv::Mat image = readImage(imageName);
     ASSERT_FALSE(image.empty());
@@ -806,7 +822,7 @@ struct MatchTemplate_CanFindBigTemplate : testing::TestWithParam<cv::gpu::Device
     }
 };
 
-TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
+GPU_TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
 {
     cv::Mat scene = readImage("matchtemplate/scene.png");
     ASSERT_FALSE(scene.empty());
@@ -829,7 +845,7 @@ TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF_NORMED)
     ASSERT_EQ(0, minLoc.y);
 }
 
-TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
+GPU_TEST_P(MatchTemplate_CanFindBigTemplate, SQDIFF)
 {
     cv::Mat scene = readImage("matchtemplate/scene.png");
     ASSERT_FALSE(scene.empty());
@@ -879,7 +895,7 @@ PARAM_TEST_CASE(MulSpectrums, cv::gpu::DeviceInfo, cv::Size, DftFlags)
     }
 };
 
-TEST_P(MulSpectrums, Simple)
+GPU_TEST_P(MulSpectrums, Simple)
 {
     cv::gpu::GpuMat c;
     cv::gpu::mulSpectrums(loadMat(a), loadMat(b), c, flag, false);
@@ -890,7 +906,7 @@ TEST_P(MulSpectrums, Simple)
     EXPECT_MAT_NEAR(c_gold, c, 1e-2);
 }
 
-TEST_P(MulSpectrums, Scaled)
+GPU_TEST_P(MulSpectrums, Scaled)
 {
     float scale = 1.f / size.area();
 
@@ -924,31 +940,34 @@ struct Dft : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
+namespace
 {
-    SCOPED_TRACE(hint);
-
-    cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);
-
-    cv::Mat b_gold;
-    cv::dft(a, b_gold, flags);
-
-    cv::gpu::GpuMat d_b;
-    cv::gpu::GpuMat d_b_data;
-    if (inplace)
+    void testC2C(const std::string& hint, int cols, int rows, int flags, bool inplace)
     {
-        d_b_data.create(1, a.size().area(), CV_32FC2);
-        d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
-    }
-    cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);
+        SCOPED_TRACE(hint);
 
-    EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
-    ASSERT_EQ(CV_32F, d_b.depth());
-    ASSERT_EQ(2, d_b.channels());
-    EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
+        cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC2, 0.0, 10.0);
+
+        cv::Mat b_gold;
+        cv::dft(a, b_gold, flags);
+
+        cv::gpu::GpuMat d_b;
+        cv::gpu::GpuMat d_b_data;
+        if (inplace)
+        {
+            d_b_data.create(1, a.size().area(), CV_32FC2);
+            d_b = cv::gpu::GpuMat(a.rows, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+        }
+        cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), flags);
+
+        EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+        ASSERT_EQ(CV_32F, d_b.depth());
+        ASSERT_EQ(2, d_b.channels());
+        EXPECT_MAT_NEAR(b_gold, cv::Mat(d_b), rows * cols * 1e-4);
+    }
 }
 
-TEST_P(Dft, C2C)
+GPU_TEST_P(Dft, C2C)
 {
     int cols = randomInt(2, 100);
     int rows = randomInt(2, 100);
@@ -973,43 +992,46 @@ TEST_P(Dft, C2C)
     }
 }
 
-void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
+namespace
 {
-    SCOPED_TRACE(hint);
-
-    cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);
-
-    cv::gpu::GpuMat d_b, d_c;
-    cv::gpu::GpuMat d_b_data, d_c_data;
-    if (inplace)
+    void testR2CThenC2R(const std::string& hint, int cols, int rows, bool inplace)
     {
-        if (a.cols == 1)
+        SCOPED_TRACE(hint);
+
+        cv::Mat a = randomMat(cv::Size(cols, rows), CV_32FC1, 0.0, 10.0);
+
+        cv::gpu::GpuMat d_b, d_c;
+        cv::gpu::GpuMat d_b_data, d_c_data;
+        if (inplace)
         {
-            d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
-            d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+            if (a.cols == 1)
+            {
+                d_b_data.create(1, (a.rows / 2 + 1) * a.cols, CV_32FC2);
+                d_b = cv::gpu::GpuMat(a.rows / 2 + 1, a.cols, CV_32FC2, d_b_data.ptr(), a.cols * d_b_data.elemSize());
+            }
+            else
+            {
+                d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
+                d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
+            }
+            d_c_data.create(1, a.size().area(), CV_32F);
+            d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
         }
-        else
-        {
-            d_b_data.create(1, a.rows * (a.cols / 2 + 1), CV_32FC2);
-            d_b = cv::gpu::GpuMat(a.rows, a.cols / 2 + 1, CV_32FC2, d_b_data.ptr(), (a.cols / 2 + 1) * d_b_data.elemSize());
-        }
-        d_c_data.create(1, a.size().area(), CV_32F);
-        d_c = cv::gpu::GpuMat(a.rows, a.cols, CV_32F, d_c_data.ptr(), a.cols * d_c_data.elemSize());
+
+        cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);
+        cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
+
+        EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
+        EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
+        ASSERT_EQ(CV_32F, d_c.depth());
+        ASSERT_EQ(1, d_c.channels());
+
+        cv::Mat c(d_c);
+        EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
     }
-
-    cv::gpu::dft(loadMat(a), d_b, cv::Size(cols, rows), 0);
-    cv::gpu::dft(d_b, d_c, cv::Size(cols, rows), cv::DFT_REAL_OUTPUT | cv::DFT_SCALE);
-
-    EXPECT_TRUE(!inplace || d_b.ptr() == d_b_data.ptr());
-    EXPECT_TRUE(!inplace || d_c.ptr() == d_c_data.ptr());
-    ASSERT_EQ(CV_32F, d_c.depth());
-    ASSERT_EQ(1, d_c.channels());
-
-    cv::Mat c(d_c);
-    EXPECT_MAT_NEAR(a, c, rows * cols * 1e-5);
 }
 
-TEST_P(Dft, R2CThenC2R)
+GPU_TEST_P(Dft, R2CThenC2R)
 {
     int cols = randomInt(2, 100);
     int rows = randomInt(2, 100);
@@ -1036,8 +1058,11 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Dft, ALL_DEVICES);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // CornerHarris
 
-IMPLEMENT_PARAM_CLASS(BlockSize, int);
-IMPLEMENT_PARAM_CLASS(ApertureSize, int);
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(BlockSize, int);
+    IMPLEMENT_PARAM_CLASS(ApertureSize, int);
+}
 
 PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSize, ApertureSize)
 {
@@ -1059,7 +1084,7 @@ PARAM_TEST_CASE(CornerHarris, cv::gpu::DeviceInfo, MatType, BorderType, BlockSiz
     }
 };
 
-TEST_P(CornerHarris, Accuracy)
+GPU_TEST_P(CornerHarris, Accuracy)
 {
     cv::Mat src = readImageType("stereobm/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
@@ -1105,7 +1130,7 @@ PARAM_TEST_CASE(CornerMinEigen, cv::gpu::DeviceInfo, MatType, BorderType, BlockS
     }
 };
 
-TEST_P(CornerMinEigen, Accuracy)
+GPU_TEST_P(CornerMinEigen, Accuracy)
 {
     cv::Mat src = readImageType("stereobm/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
@@ -1126,6 +1151,4 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, CornerMinEigen, testing::Combine(
     testing::Values(BlockSize(3), BlockSize(5), BlockSize(7)),
     testing::Values(ApertureSize(0), ApertureSize(3), ApertureSize(5), ApertureSize(7))));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_labeling.cpp b/modules/gpu/test/test_labeling.cpp
index 68d2cf404..b19fd2e1b 100644
--- a/modules/gpu/test/test_labeling.cpp
+++ b/modules/gpu/test/test_labeling.cpp
@@ -43,8 +43,8 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
+namespace
+{
     struct GreedyLabeling
     {
         struct dot
@@ -166,7 +166,7 @@ struct Labeling : testing::TestWithParam<cv::gpu::DeviceInfo>
     }
 };
 
-TEST_P(Labeling, ConnectedComponents)
+GPU_TEST_P(Labeling, ConnectedComponents)
 {
     cv::Mat image;
     cvtColor(loat_image(), image, CV_BGR2GRAY);
@@ -191,6 +191,6 @@ TEST_P(Labeling, ConnectedComponents)
     host.checkCorrectness(cv::Mat(components));
 }
 
-INSTANTIATE_TEST_CASE_P(ConnectedComponents, Labeling, ALL_DEVICES);
+INSTANTIATE_TEST_CASE_P(GPU_ConnectedComponents, Labeling, ALL_DEVICES);
 
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_nvidia.cpp b/modules/gpu/test/test_nvidia.cpp
index 484f3cfbb..53ed8c223 100644
--- a/modules/gpu/test/test_nvidia.cpp
+++ b/modules/gpu/test/test_nvidia.cpp
@@ -41,11 +41,9 @@
 
 #include "test_precomp.hpp"
 
-#if defined HAVE_CUDA
-  OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
-#endif
+#ifdef HAVE_CUDA
 
-#if defined HAVE_CUDA && !defined(CUDA_DISABLER)
+OutputLevel nvidiaTestOutputLevel = OutputLevelNone;
 
 using namespace cvtest;
 using namespace testing;
@@ -69,77 +67,77 @@ struct NVidiaTest : TestWithParam<cv::gpu::DeviceInfo>
 struct NPPST : NVidiaTest {};
 struct NCV : NVidiaTest {};
 
-//TEST_P(NPPST, Integral)
-//{
-//    bool res = nvidia_NPPST_Integral_Image(path, nvidiaTestOutputLevel);
+GPU_TEST_P(NPPST, Integral)
+{
+    bool res = nvidia_NPPST_Integral_Image(_path, nvidiaTestOutputLevel);
 
-//    ASSERT_TRUE(res);
-//}
+    ASSERT_TRUE(res);
+}
 
-TEST_P(NPPST, SquaredIntegral)
+GPU_TEST_P(NPPST, SquaredIntegral)
 {
     bool res = nvidia_NPPST_Squared_Integral_Image(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NPPST, RectStdDev)
+GPU_TEST_P(NPPST, RectStdDev)
 {
     bool res = nvidia_NPPST_RectStdDev(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NPPST, Resize)
+GPU_TEST_P(NPPST, Resize)
 {
     bool res = nvidia_NPPST_Resize(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NPPST, VectorOperations)
+GPU_TEST_P(NPPST, VectorOperations)
 {
     bool res = nvidia_NPPST_Vector_Operations(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NPPST, Transpose)
+GPU_TEST_P(NPPST, Transpose)
 {
     bool res = nvidia_NPPST_Transpose(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NCV, VectorOperations)
+GPU_TEST_P(NCV, VectorOperations)
 {
     bool res = nvidia_NCV_Vector_Operations(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NCV, HaarCascadeLoader)
+GPU_TEST_P(NCV, HaarCascadeLoader)
 {
     bool res = nvidia_NCV_Haar_Cascade_Loader(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NCV, HaarCascadeApplication)
+GPU_TEST_P(NCV, HaarCascadeApplication)
 {
     bool res = nvidia_NCV_Haar_Cascade_Application(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NCV, HypothesesFiltration)
+GPU_TEST_P(NCV, HypothesesFiltration)
 {
     bool res = nvidia_NCV_Hypotheses_Filtration(_path, nvidiaTestOutputLevel);
 
     ASSERT_TRUE(res);
 }
 
-TEST_P(NCV, Visualization)
+GPU_TEST_P(NCV, Visualization)
 {
     // this functionality doesn't used in gpu module
     bool res = nvidia_NCV_Visualization(_path, nvidiaTestOutputLevel);
diff --git a/modules/gpu/test/test_objdetect.cpp b/modules/gpu/test/test_objdetect.cpp
index 4fb295d4c..fd610d9b5 100644
--- a/modules/gpu/test/test_objdetect.cpp
+++ b/modules/gpu/test/test_objdetect.cpp
@@ -43,8 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-namespace {
-
 //#define DUMP
 
 struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
@@ -176,7 +174,7 @@ struct HOG : testing::TestWithParam<cv::gpu::DeviceInfo>, cv::gpu::HOGDescriptor
 };
 
 // desabled while resize does not fixed
-TEST_P(HOG, DISABLED_Detect)
+GPU_TEST_P(HOG, Detect)
 {
     cv::Mat img_rgb = readImage("hog/road.png");
     ASSERT_FALSE(img_rgb.empty());
@@ -201,7 +199,7 @@ TEST_P(HOG, DISABLED_Detect)
     f.close();
 }
 
-TEST_P(HOG, GetDescriptors)
+GPU_TEST_P(HOG, GetDescriptors)
 {
     // Load image (e.g. train data, composed from windows)
     cv::Mat img_rgb = readImage("hog/train_data.png");
@@ -288,6 +286,7 @@ TEST_P(HOG, GetDescriptors)
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, HOG, ALL_DEVICES);
 
 //============== caltech hog tests =====================//
+
 struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string> >
 {
     cv::gpu::DeviceInfo devInfo;
@@ -303,7 +302,7 @@ struct CalTech : public ::testing::TestWithParam<std::tr1::tuple<cv::gpu::Device
     }
 };
 
-TEST_P(CalTech, HOG)
+GPU_TEST_P(CalTech, HOG)
 {
     cv::gpu::GpuMat d_img(img);
     cv::Mat markedImage(img.clone());
@@ -350,7 +349,7 @@ PARAM_TEST_CASE(LBP_Read_classifier, cv::gpu::DeviceInfo, int)
     }
 };
 
-TEST_P(LBP_Read_classifier, Accuracy)
+GPU_TEST_P(LBP_Read_classifier, Accuracy)
 {
     cv::gpu::CascadeClassifier_GPU classifier;
     std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
@@ -372,7 +371,7 @@ PARAM_TEST_CASE(LBP_classify, cv::gpu::DeviceInfo, int)
     }
 };
 
-TEST_P(LBP_classify, Accuracy)
+GPU_TEST_P(LBP_classify, Accuracy)
 {
     std::string classifierXmlPath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/lbpcascade_frontalface.xml";
     std::string imagePath = std::string(cvtest::TS::ptr()->get_data_path()) + "lbpcascade/er.png";
@@ -422,6 +421,4 @@ TEST_P(LBP_classify, Accuracy)
 INSTANTIATE_TEST_CASE_P(GPU_ObjDetect, LBP_classify,
                         testing::Combine(ALL_DEVICES, testing::Values<int>(0)));
 
-} // namespace
-
 #endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp
index 3bb3e09ea..9b69db6d4 100644
--- a/modules/gpu/test/test_opengl.cpp
+++ b/modules/gpu/test/test_opengl.cpp
@@ -68,7 +68,7 @@ PARAM_TEST_CASE(GlBuffer, cv::Size, MatType)
     }
 };
 
-TEST_P(GlBuffer, Constructor1)
+GPU_TEST_P(GlBuffer, Constructor1)
 {
     cv::GlBuffer buf(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
@@ -77,7 +77,7 @@ TEST_P(GlBuffer, Constructor1)
     EXPECT_EQ(type, buf.type());
 }
 
-TEST_P(GlBuffer, Constructor2)
+GPU_TEST_P(GlBuffer, Constructor2)
 {
     cv::GlBuffer buf(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
@@ -86,7 +86,7 @@ TEST_P(GlBuffer, Constructor2)
     EXPECT_EQ(type, buf.type());
 }
 
-TEST_P(GlBuffer, ConstructorFromMat)
+GPU_TEST_P(GlBuffer, ConstructorFromMat)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -98,7 +98,7 @@ TEST_P(GlBuffer, ConstructorFromMat)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, ConstructorFromGpuMat)
+GPU_TEST_P(GlBuffer, ConstructorFromGpuMat)
 {
     cv::Mat gold = randomMat(size, type);
     cv::gpu::GpuMat d_gold(gold);
@@ -111,7 +111,7 @@ TEST_P(GlBuffer, ConstructorFromGpuMat)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, ConstructorFromGlBuffer)
+GPU_TEST_P(GlBuffer, ConstructorFromGlBuffer)
 {
     cv::GlBuffer buf_gold(size, type, cv::GlBuffer::ARRAY_BUFFER, true);
 
@@ -123,7 +123,7 @@ TEST_P(GlBuffer, ConstructorFromGlBuffer)
     EXPECT_EQ(buf_gold.type(), buf.type());
 }
 
-TEST_P(GlBuffer, ConstructorFromGlTexture2D)
+GPU_TEST_P(GlBuffer, ConstructorFromGlTexture2D)
 {
     const int depth = CV_MAT_DEPTH(type);
     const int cn = CV_MAT_CN(type);
@@ -142,7 +142,7 @@ TEST_P(GlBuffer, ConstructorFromGlTexture2D)
     EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
-TEST_P(GlBuffer, Create)
+GPU_TEST_P(GlBuffer, Create)
 {
     cv::GlBuffer buf;
     buf.create(size.height, size.width, type, cv::GlBuffer::ARRAY_BUFFER, true);
@@ -152,7 +152,7 @@ TEST_P(GlBuffer, Create)
     EXPECT_EQ(type, buf.type());
 }
 
-TEST_P(GlBuffer, CopyFromMat)
+GPU_TEST_P(GlBuffer, CopyFromMat)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -165,7 +165,7 @@ TEST_P(GlBuffer, CopyFromMat)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, CopyFromGpuMat)
+GPU_TEST_P(GlBuffer, CopyFromGpuMat)
 {
     cv::Mat gold = randomMat(size, type);
     cv::gpu::GpuMat d_gold(gold);
@@ -179,7 +179,7 @@ TEST_P(GlBuffer, CopyFromGpuMat)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, CopyFromGlBuffer)
+GPU_TEST_P(GlBuffer, CopyFromGlBuffer)
 {
     cv::Mat gold = randomMat(size, type);
     cv::GlBuffer buf_gold(gold, cv::GlBuffer::ARRAY_BUFFER, true);
@@ -195,7 +195,7 @@ TEST_P(GlBuffer, CopyFromGlBuffer)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, CopyFromGlTexture2D)
+GPU_TEST_P(GlBuffer, CopyFromGlTexture2D)
 {
     const int depth = CV_MAT_DEPTH(type);
     const int cn = CV_MAT_CN(type);
@@ -215,7 +215,7 @@ TEST_P(GlBuffer, CopyFromGlTexture2D)
     EXPECT_MAT_NEAR(gold, bufData, 1e-2);
 }
 
-TEST_P(GlBuffer, CopyToGpuMat)
+GPU_TEST_P(GlBuffer, CopyToGpuMat)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -227,7 +227,7 @@ TEST_P(GlBuffer, CopyToGpuMat)
     EXPECT_MAT_NEAR(gold, dst, 0);
 }
 
-TEST_P(GlBuffer, CopyToGlBuffer)
+GPU_TEST_P(GlBuffer, CopyToGlBuffer)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -244,7 +244,7 @@ TEST_P(GlBuffer, CopyToGlBuffer)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, CopyToGlTexture2D)
+GPU_TEST_P(GlBuffer, CopyToGlTexture2D)
 {
     const int depth = CV_MAT_DEPTH(type);
     const int cn = CV_MAT_CN(type);
@@ -265,7 +265,7 @@ TEST_P(GlBuffer, CopyToGlTexture2D)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlBuffer, Clone)
+GPU_TEST_P(GlBuffer, Clone)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -281,7 +281,7 @@ TEST_P(GlBuffer, Clone)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, MapHostRead)
+GPU_TEST_P(GlBuffer, MapHostRead)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -294,7 +294,7 @@ TEST_P(GlBuffer, MapHostRead)
     buf.unmapHost();
 }
 
-TEST_P(GlBuffer, MapHostWrite)
+GPU_TEST_P(GlBuffer, MapHostWrite)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -311,7 +311,7 @@ TEST_P(GlBuffer, MapHostWrite)
     EXPECT_MAT_NEAR(gold, bufData, 0);
 }
 
-TEST_P(GlBuffer, MapDevice)
+GPU_TEST_P(GlBuffer, MapDevice)
 {
     cv::Mat gold = randomMat(size, type);
 
@@ -358,7 +358,7 @@ PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType)
     }
 };
 
-TEST_P(GlTexture2D, Constructor1)
+GPU_TEST_P(GlTexture2D, Constructor1)
 {
     cv::GlTexture2D tex(size.height, size.width, format, true);
 
@@ -367,7 +367,7 @@ TEST_P(GlTexture2D, Constructor1)
     EXPECT_EQ(format, tex.format());
 }
 
-TEST_P(GlTexture2D, Constructor2)
+GPU_TEST_P(GlTexture2D, Constructor2)
 {
     cv::GlTexture2D tex(size, format, true);
 
@@ -376,7 +376,7 @@ TEST_P(GlTexture2D, Constructor2)
     EXPECT_EQ(format, tex.format());
 }
 
-TEST_P(GlTexture2D, ConstructorFromMat)
+GPU_TEST_P(GlTexture2D, ConstructorFromMat)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
@@ -388,7 +388,7 @@ TEST_P(GlTexture2D, ConstructorFromMat)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, ConstructorFromGpuMat)
+GPU_TEST_P(GlTexture2D, ConstructorFromGpuMat)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::gpu::GpuMat d_gold(gold);
@@ -401,7 +401,7 @@ TEST_P(GlTexture2D, ConstructorFromGpuMat)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, ConstructorFromGlBuffer)
+GPU_TEST_P(GlTexture2D, ConstructorFromGlBuffer)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
@@ -414,7 +414,7 @@ TEST_P(GlTexture2D, ConstructorFromGlBuffer)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
+GPU_TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
 {
     cv::GlTexture2D tex_gold(size, format, true);
     cv::GlTexture2D tex(tex_gold);
@@ -425,7 +425,7 @@ TEST_P(GlTexture2D, ConstructorFromGlTexture2D)
     EXPECT_EQ(tex_gold.format(), tex.format());
 }
 
-TEST_P(GlTexture2D, Create)
+GPU_TEST_P(GlTexture2D, Create)
 {
     cv::GlTexture2D tex;
     tex.create(size.height, size.width, format, true);
@@ -435,7 +435,7 @@ TEST_P(GlTexture2D, Create)
     EXPECT_EQ(format, tex.format());
 }
 
-TEST_P(GlTexture2D, CopyFromMat)
+GPU_TEST_P(GlTexture2D, CopyFromMat)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
@@ -448,7 +448,7 @@ TEST_P(GlTexture2D, CopyFromMat)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, CopyFromGpuMat)
+GPU_TEST_P(GlTexture2D, CopyFromGpuMat)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::gpu::GpuMat d_gold(gold);
@@ -462,7 +462,7 @@ TEST_P(GlTexture2D, CopyFromGpuMat)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, CopyFromGlBuffer)
+GPU_TEST_P(GlTexture2D, CopyFromGlBuffer)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
     cv::GlBuffer buf_gold(gold, cv::GlBuffer::PIXEL_UNPACK_BUFFER, true);
@@ -476,7 +476,7 @@ TEST_P(GlTexture2D, CopyFromGlBuffer)
     EXPECT_MAT_NEAR(gold, texData, 1e-2);
 }
 
-TEST_P(GlTexture2D, CopyToGpuMat)
+GPU_TEST_P(GlTexture2D, CopyToGpuMat)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
@@ -488,7 +488,7 @@ TEST_P(GlTexture2D, CopyToGpuMat)
     EXPECT_MAT_NEAR(gold, dst, 1e-2);
 }
 
-TEST_P(GlTexture2D, CopyToGlBuffer)
+GPU_TEST_P(GlTexture2D, CopyToGlBuffer)
 {
     cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1);
 
diff --git a/modules/gpu/test/test_optflow.cpp b/modules/gpu/test/test_optflow.cpp
new file mode 100644
index 000000000..c93ebbe19
--- /dev/null
+++ b/modules/gpu/test/test_optflow.cpp
@@ -0,0 +1,623 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                        Intel License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of Intel Corporation may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+#include "test_precomp.hpp"
+
+#ifdef HAVE_CUDA
+
+//////////////////////////////////////////////////////
+// BroxOpticalFlow
+
+//#define BROX_DUMP
+
+struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+    cv::gpu::DeviceInfo devInfo;
+
+    virtual void SetUp()
+    {
+        devInfo = GetParam();
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+GPU_TEST_P(BroxOpticalFlow, Regression)
+{
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(frame0), loadMat(frame1), u, v);
+
+    std::string fname(cvtest::TS::ptr()->get_data_path());
+    if (devInfo.majorVersion() >= 2)
+        fname += "opticalflow/brox_optical_flow_cc20.bin";
+    else
+        fname += "opticalflow/brox_optical_flow.bin";
+
+#ifndef BROX_DUMP
+    std::ifstream f(fname.c_str(), std::ios_base::binary);
+
+    int rows, cols;
+
+    f.read((char*) &rows, sizeof(rows));
+    f.read((char*) &cols, sizeof(cols));
+
+    cv::Mat u_gold(rows, cols, CV_32FC1);
+
+    for (int i = 0; i < u_gold.rows; ++i)
+        f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
+
+    cv::Mat v_gold(rows, cols, CV_32FC1);
+
+    for (int i = 0; i < v_gold.rows; ++i)
+        f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
+
+    EXPECT_MAT_NEAR(u_gold, u, 0);
+    EXPECT_MAT_NEAR(v_gold, v, 0);
+#else
+    std::ofstream f(fname.c_str(), std::ios_base::binary);
+
+    f.write((char*) &u.rows, sizeof(u.rows));
+    f.write((char*) &u.cols, sizeof(u.cols));
+
+    cv::Mat h_u(u);
+    cv::Mat h_v(v);
+
+    for (int i = 0; i < u.rows; ++i)
+        f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
+
+    for (int i = 0; i < v.rows; ++i)
+        f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
+#endif
+}
+
+GPU_TEST_P(BroxOpticalFlow, OpticalFlowNan)
+{
+    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Mat r_frame0, r_frame1;
+    cv::resize(frame0, r_frame0, cv::Size(1380,1000));
+    cv::resize(frame1, r_frame1, cv::Size(1380,1000));
+
+    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
+                                  5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
+
+    cv::gpu::GpuMat u;
+    cv::gpu::GpuMat v;
+    brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
+
+    cv::Mat h_u, h_v;
+    u.download(h_u);
+    v.download(h_v);
+
+    EXPECT_TRUE(cv::checkRange(h_u));
+    EXPECT_TRUE(cv::checkRange(h_v));
+};
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
+
+//////////////////////////////////////////////////////
+// GoodFeaturesToTrack
+
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(MinDistance, double)
+}
+
+PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
+{
+    cv::gpu::DeviceInfo devInfo;
+    double minDistance;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        minDistance = GET_PARAM(1);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+GPU_TEST_P(GoodFeaturesToTrack, Accuracy)
+{
+    cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(image.empty());
+
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
+
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+
+    cv::gpu::GpuMat d_pts;
+    detector(loadMat(image), d_pts);
+
+    ASSERT_FALSE(d_pts.empty());
+
+    std::vector<cv::Point2f> pts(d_pts.cols);
+    cv::Mat pts_mat(1, d_pts.cols, CV_32FC2, (void*) &pts[0]);
+    d_pts.download(pts_mat);
+
+    std::vector<cv::Point2f> pts_gold;
+    cv::goodFeaturesToTrack(image, pts_gold, maxCorners, qualityLevel, minDistance);
+
+    ASSERT_EQ(pts_gold.size(), pts.size());
+
+    size_t mistmatch = 0;
+    for (size_t i = 0; i < pts.size(); ++i)
+    {
+        cv::Point2i a = pts_gold[i];
+        cv::Point2i b = pts[i];
+
+        bool eq = std::abs(a.x - b.x) < 1 && std::abs(a.y - b.y) < 1;
+
+        if (!eq)
+            ++mistmatch;
+    }
+
+    double bad_ratio = static_cast<double>(mistmatch) / pts.size();
+
+    ASSERT_LE(bad_ratio, 0.01);
+}
+
+GPU_TEST_P(GoodFeaturesToTrack, EmptyCorners)
+{
+    int maxCorners = 1000;
+    double qualityLevel = 0.01;
+
+    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
+
+    cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
+    cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
+
+    detector(src, corners);
+
+    ASSERT_TRUE(corners.empty());
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(MinDistance(0.0), MinDistance(3.0))));
+
+//////////////////////////////////////////////////////
+// PyrLKOpticalFlow
+
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(UseGray, bool)
+}
+
+PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
+{
+    cv::gpu::DeviceInfo devInfo;
+    bool useGray;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        useGray = GET_PARAM(1);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+GPU_TEST_P(PyrLKOpticalFlow, Sparse)
+{
+    cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Mat gray_frame;
+    if (useGray)
+        gray_frame = frame0;
+    else
+        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
+
+    std::vector<cv::Point2f> pts;
+    cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
+
+    cv::gpu::GpuMat d_pts;
+    cv::Mat pts_mat(1, (int) pts.size(), CV_32FC2, (void*) &pts[0]);
+    d_pts.upload(pts_mat);
+
+    cv::gpu::PyrLKOpticalFlow pyrLK;
+
+    cv::gpu::GpuMat d_nextPts;
+    cv::gpu::GpuMat d_status;
+    pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
+
+    std::vector<cv::Point2f> nextPts(d_nextPts.cols);
+    cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*) &nextPts[0]);
+    d_nextPts.download(nextPts_mat);
+
+    std::vector<unsigned char> status(d_status.cols);
+    cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*) &status[0]);
+    d_status.download(status_mat);
+
+    std::vector<cv::Point2f> nextPts_gold;
+    std::vector<unsigned char> status_gold;
+    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
+
+    ASSERT_EQ(nextPts_gold.size(), nextPts.size());
+    ASSERT_EQ(status_gold.size(), status.size());
+
+    size_t mistmatch = 0;
+    for (size_t i = 0; i < nextPts.size(); ++i)
+    {
+        cv::Point2i a = nextPts[i];
+        cv::Point2i b = nextPts_gold[i];
+
+        if (status[i] != status_gold[i])
+        {
+            ++mistmatch;
+            continue;
+        }
+
+        if (status[i])
+        {
+            bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
+
+            if (!eq)
+                ++mistmatch;
+        }
+    }
+
+    double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
+
+    ASSERT_LE(bad_ratio, 0.01);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(UseGray(true), UseGray(false))));
+
+//////////////////////////////////////////////////////
+// FarnebackOpticalFlow
+
+namespace
+{
+    IMPLEMENT_PARAM_CLASS(PyrScale, double)
+    IMPLEMENT_PARAM_CLASS(PolyN, int)
+    CV_FLAGS(FarnebackOptFlowFlags, 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN)
+    IMPLEMENT_PARAM_CLASS(UseInitFlow, bool)
+}
+
+PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, FarnebackOptFlowFlags, UseInitFlow)
+{
+    cv::gpu::DeviceInfo devInfo;
+    double pyrScale;
+    int polyN;
+    int flags;
+    bool useInitFlow;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        pyrScale = GET_PARAM(1);
+        polyN = GET_PARAM(2);
+        flags = GET_PARAM(3);
+        useInitFlow = GET_PARAM(4);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+GPU_TEST_P(FarnebackOpticalFlow, Accuracy)
+{
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    double polySigma = polyN <= 5 ? 1.1 : 1.5;
+
+    cv::gpu::FarnebackOpticalFlow farn;
+    farn.pyrScale = pyrScale;
+    farn.polyN = polyN;
+    farn.polySigma = polySigma;
+    farn.flags = flags;
+
+    cv::gpu::GpuMat d_flowx, d_flowy;
+    farn(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+
+    cv::Mat flow;
+    if (useInitFlow)
+    {
+        cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
+        cv::merge(flowxy, 2, flow);
+
+        farn.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
+        farn(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
+    }
+
+    cv::calcOpticalFlowFarneback(
+        frame0, frame1, flow, farn.pyrScale, farn.numLevels, farn.winSize,
+        farn.numIters, farn.polyN, farn.polySigma, farn.flags);
+
+    std::vector<cv::Mat> flowxy;
+    cv::split(flow, flowxy);
+
+    EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
+    EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(PyrScale(0.3), PyrScale(0.5), PyrScale(0.8)),
+    testing::Values(PolyN(5), PolyN(7)),
+    testing::Values(FarnebackOptFlowFlags(0), FarnebackOptFlowFlags(cv::OPTFLOW_FARNEBACK_GAUSSIAN)),
+    testing::Values(UseInitFlow(false), UseInitFlow(true))));
+
+//////////////////////////////////////////////////////
+// OpticalFlowDual_TVL1
+
+PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
+{
+    cv::gpu::DeviceInfo devInfo;
+    bool useRoi;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        useRoi = GET_PARAM(1);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+    }
+};
+
+GPU_TEST_P(OpticalFlowDual_TVL1, Accuracy)
+{
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
+    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
+    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
+    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
+
+    cv::OpticalFlowDual_TVL1 alg;
+    cv::Mat flow;
+    alg(frame0, frame1, flow);
+    cv::Mat gold[2];
+    cv::split(flow, gold);
+
+    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
+    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
+    ALL_DEVICES,
+    WHOLE_SUBMAT));
+
+//////////////////////////////////////////////////////
+// OpticalFlowBM
+
+namespace
+{
+    void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
+                           cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
+                           cv::Mat& velx, cv::Mat& vely)
+    {
+        cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
+
+        velx.create(sz, CV_32FC1);
+        vely.create(sz, CV_32FC1);
+
+        CvMat cvprev = prev;
+        CvMat cvcurr = curr;
+
+        CvMat cvvelx = velx;
+        CvMat cvvely = vely;
+
+        cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
+    }
+}
+
+struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+};
+
+GPU_TEST_P(OpticalFlowBM, Accuracy)
+{
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size block_size(16, 16);
+    cv::Size shift_size(1, 1);
+    cv::Size max_range(16, 16);
+
+    cv::gpu::GpuMat d_velx, d_vely, buf;
+    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
+                               block_size, shift_size, max_range, false,
+                               d_velx, d_vely, buf);
+
+    cv::Mat velx, vely;
+    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
+
+    EXPECT_MAT_NEAR(velx, d_velx, 0);
+    EXPECT_MAT_NEAR(vely, d_vely, 0);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
+
+//////////////////////////////////////////////////////
+// FastOpticalFlowBM
+
+namespace
+{
+    void FastOpticalFlowBM_gold(const cv::Mat_<uchar>& I0, const cv::Mat_<uchar>& I1, cv::Mat_<float>& velx, cv::Mat_<float>& vely, int search_window, int block_window)
+    {
+        velx.create(I0.size());
+        vely.create(I0.size());
+
+        int search_radius = search_window / 2;
+        int block_radius = block_window / 2;
+
+        for (int y = 0; y < I0.rows; ++y)
+        {
+            for (int x = 0; x < I0.cols; ++x)
+            {
+                int bestDist = std::numeric_limits<int>::max();
+                int bestDx = 0;
+                int bestDy = 0;
+
+                for (int dy = -search_radius; dy <= search_radius; ++dy)
+                {
+                    for (int dx = -search_radius; dx <= search_radius; ++dx)
+                    {
+                        int dist = 0;
+
+                        for (int by = -block_radius; by <= block_radius; ++by)
+                        {
+                            for (int bx = -block_radius; bx <= block_radius; ++bx)
+                            {
+                                int I0_val = I0(cv::borderInterpolate(y + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + bx, I0.cols, cv::BORDER_DEFAULT));
+                                int I1_val = I1(cv::borderInterpolate(y + dy + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + dx + bx, I0.cols, cv::BORDER_DEFAULT));
+
+                                dist += std::abs(I0_val - I1_val);
+                            }
+                        }
+
+                        if (dist < bestDist)
+                        {
+                            bestDist = dist;
+                            bestDx = dx;
+                            bestDy = dy;
+                        }
+                    }
+                }
+
+                velx(y, x) = (float) bestDx;
+                vely(y, x) = (float) bestDy;
+            }
+        }
+    }
+
+    double calc_rmse(const cv::Mat_<float>& flow1, const cv::Mat_<float>& flow2)
+    {
+        double sum = 0.0;
+
+        for (int y = 0; y < flow1.rows; ++y)
+        {
+            for (int x = 0; x < flow1.cols; ++x)
+            {
+                double diff = flow1(y, x) - flow2(y, x);
+                sum += diff * diff;
+            }
+        }
+
+        return std::sqrt(sum / flow1.size().area());
+    }
+}
+
+struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
+{
+};
+
+GPU_TEST_P(FastOpticalFlowBM, Accuracy)
+{
+    const double MAX_RMSE = 0.6;
+
+    int search_window = 15;
+    int block_window = 5;
+
+    cv::gpu::DeviceInfo devInfo = GetParam();
+    cv::gpu::setDevice(devInfo.deviceID());
+
+    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame0.empty());
+
+    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
+    ASSERT_FALSE(frame1.empty());
+
+    cv::Size smallSize(320, 240);
+    cv::Mat frame0_small;
+    cv::Mat frame1_small;
+
+    cv::resize(frame0, frame0_small, smallSize);
+    cv::resize(frame1, frame1_small, smallSize);
+
+    cv::gpu::GpuMat d_flowx;
+    cv::gpu::GpuMat d_flowy;
+    cv::gpu::FastOpticalFlowBM fastBM;
+
+    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
+
+    cv::Mat_<float> flowx;
+    cv::Mat_<float> flowy;
+    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
+
+    double err;
+
+    err = calc_rmse(flowx, cv::Mat(d_flowx));
+    EXPECT_LE(err, MAX_RMSE);
+
+    err = calc_rmse(flowy, cv::Mat(d_flowy));
+    EXPECT_LE(err, MAX_RMSE);
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
+
+#endif // HAVE_CUDA
diff --git a/modules/gpu/test/test_precomp.hpp b/modules/gpu/test/test_precomp.hpp
index 7eb53d5f3..e7ade6aed 100644
--- a/modules/gpu/test/test_precomp.hpp
+++ b/modules/gpu/test/test_precomp.hpp
@@ -51,6 +51,7 @@
 #define __OPENCV_TEST_PRECOMP_HPP__
 
 #include <cmath>
+#include <ctime>
 #include <cstdio>
 #include <iostream>
 #include <fstream>
diff --git a/modules/gpu/test/test_pyramids.cpp b/modules/gpu/test/test_pyramids.cpp
index 1abd7841e..c3d56b63a 100644
--- a/modules/gpu/test/test_pyramids.cpp
+++ b/modules/gpu/test/test_pyramids.cpp
@@ -64,7 +64,7 @@ PARAM_TEST_CASE(PyrDown, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(PyrDown, Accuracy)
+GPU_TEST_P(PyrDown, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -104,7 +104,7 @@ PARAM_TEST_CASE(PyrUp, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
     }
 };
 
-TEST_P(PyrUp, Accuracy)
+GPU_TEST_P(PyrUp, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
diff --git a/modules/gpu/test/test_remap.cpp b/modules/gpu/test/test_remap.cpp
index 978e1044a..a815ed0e0 100644
--- a/modules/gpu/test/test_remap.cpp
+++ b/modules/gpu/test/test_remap.cpp
@@ -152,7 +152,7 @@ PARAM_TEST_CASE(Remap, cv::gpu::DeviceInfo, cv::Size, MatType, Interpolation, Bo
     }
 };
 
-TEST_P(Remap, Accuracy)
+GPU_TEST_P(Remap, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Scalar val = randomScalar(0.0, 255.0);
diff --git a/modules/gpu/test/test_resize.cpp b/modules/gpu/test/test_resize.cpp
index cae2dbf41..a34da54fd 100644
--- a/modules/gpu/test/test_resize.cpp
+++ b/modules/gpu/test/test_resize.cpp
@@ -136,7 +136,7 @@ PARAM_TEST_CASE(Resize, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpol
     }
 };
 
-TEST_P(Resize, Accuracy)
+GPU_TEST_P(Resize, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -157,8 +157,8 @@ INSTANTIATE_TEST_CASE_P(GPU_ImgProc, Resize, testing::Combine(
     testing::Values(Interpolation(cv::INTER_NEAREST), Interpolation(cv::INTER_LINEAR), Interpolation(cv::INTER_CUBIC)),
     WHOLE_SUBMAT));
 
-
 /////////////////
+
 PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double, Interpolation, UseRoi)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -182,7 +182,7 @@ PARAM_TEST_CASE(ResizeSameAsHost, cv::gpu::DeviceInfo, cv::Size, MatType, double
 };
 
 // downscaling only: used for classifiers
-TEST_P(ResizeSameAsHost, Accuracy)
+GPU_TEST_P(ResizeSameAsHost, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
 
@@ -224,7 +224,7 @@ PARAM_TEST_CASE(ResizeNPP, cv::gpu::DeviceInfo, MatType, double, Interpolation)
     }
 };
 
-TEST_P(ResizeNPP, Accuracy)
+GPU_TEST_P(ResizeNPP, Accuracy)
 {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     ASSERT_FALSE(src.empty());
diff --git a/modules/gpu/test/test_softcascade.cpp b/modules/gpu/test/test_softcascade.cpp
index cc397404a..9cc1a5e39 100644
--- a/modules/gpu/test/test_softcascade.cpp
+++ b/modules/gpu/test/test_softcascade.cpp
@@ -40,14 +40,14 @@
 //
 //M*/
 
-#include <test_precomp.hpp>
-#include <time.h>
+#include "test_precomp.hpp"
 
 #ifdef HAVE_CUDA
+
 using cv::gpu::GpuMat;
 
 // show detection results on input image with cv::imshow
-// #define SHOW_DETECTIONS
+//#define SHOW_DETECTIONS
 
 #if defined SHOW_DETECTIONS
 # define SHOW(res)           \
@@ -57,22 +57,22 @@ using cv::gpu::GpuMat;
 # define SHOW(res)
 #endif
 
-#define GPU_TEST_P(fixture, name, params)                         \
-    class fixture##_##name : public fixture {                     \
-     public:                                                      \
-      fixture##_##name() {}                                       \
-     protected:                                                   \
-      virtual void body();                                        \
-    };                                                            \
-    TEST_P(fixture##_##name, name /*none*/){ body();}             \
-    INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);  \
-    void fixture##_##name::body()
+TEST(SCascadeTest, readCascade)
+{
+    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
+    cv::gpu::SCascade cascade;
 
-namespace {
+    cv::FileStorage fs(xml, cv::FileStorage::READ);
+    ASSERT_TRUE(fs.isOpened());
 
+    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
+}
+
+namespace
+{
     typedef cv::gpu::SCascade::Detection Detection;
 
-    static cv::Rect getFromTable(int idx)
+    cv::Rect getFromTable(int idx)
     {
         static const cv::Rect rois[] =
         {
@@ -92,16 +92,16 @@ namespace {
         return rois[idx];
     }
 
-    static std::string itoa(long i)
+    std::string itoa(long i)
     {
         static char s[65];
         sprintf(s, "%ld", i);
         return std::string(s);
     }
 
-    static void print(std::ostream &out, const Detection& d)
+    void print(std::ostream &out, const Detection& d)
     {
-#if defined SHOW_DETECTIONS
+    #if defined SHOW_DETECTIONS
         out << "\x1b[32m[ detection]\x1b[0m ("
             << std::setw(4)  << d.x
             << " "
@@ -113,22 +113,22 @@ namespace {
             << ") "
             << std::setw(12) << d.confidence
             <<  std::endl;
-#else
+    #else
         (void)out; (void)d;
-#endif
+    #endif
     }
 
-    static void printTotal(std::ostream &out, int detbytes)
+    void printTotal(std::ostream &out, int detbytes)
     {
-#if defined SHOW_DETECTIONS
+    #if defined SHOW_DETECTIONS
         out << "\x1b[32m[          ]\x1b[0m Total detections " << (detbytes / sizeof(Detection)) << std::endl;
-#else
+    #else
         (void)out; (void)detbytes;
-#endif
+    #endif
     }
 
 #if defined SHOW_DETECTIONS
-    static std::string getImageName(int level)
+    std::string getImageName(int level)
     {
         time_t rawtime;
         struct tm * timeinfo;
@@ -141,7 +141,7 @@ namespace {
         return "gpu_rec_level_" + itoa(level)+ "_" + std::string(buffer) + ".png";
     }
 
-    static void writeResult(const cv::Mat& result, const int level)
+    void writeResult(const cv::Mat& result, const int level)
     {
         std::string path = cv::tempfile(getImageName(level).c_str());
         cv::imwrite(path, result);
@@ -150,13 +150,11 @@ namespace {
 #endif
 }
 
-typedef ::testing::TestWithParam<std::tr1::tuple<cv::gpu::DeviceInfo, std::string, std::string, int> > SCascadeTestRoi;
-GPU_TEST_P(SCascadeTestRoi, detect,
-    testing::Combine(
-        ALL_DEVICES,
-        testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
-        testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
-        testing::Range(0, 5)))
+PARAM_TEST_CASE(SCascadeTestRoi, cv::gpu::DeviceInfo, std::string, std::string, int)
+{
+};
+
+GPU_TEST_P(SCascadeTestRoi, Detect)
 {
     cv::gpu::setDevice(GET_PARAM(0).deviceID());
     cv::Mat coloredCpu = cv::imread(cvtest::TS::ptr()->get_data_path() + GET_PARAM(2));
@@ -202,26 +200,24 @@ GPU_TEST_P(SCascadeTestRoi, detect,
     }
 
     SHOW(result);
-
 }
 
-TEST(SCascadeTest, readCascade)
+INSTANTIATE_TEST_CASE_P(GPU_SoftCascade, SCascadeTestRoi, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
+    testing::Values(std::string("../cv/cascadeandhog/bahnhof/image_00000000_0.png")),
+    testing::Range(0, 5)));
+
+struct SCascadeTestAll : testing::TestWithParam<cv::gpu::DeviceInfo>
 {
-    std::string xml = cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/icf-template.xml";
-    cv::gpu::SCascade cascade;
+    virtual void SetUp()
+    {
+        cv::gpu::setDevice(GetParam().deviceID());
+    }
+};
 
-    cv::FileStorage fs(xml, cv::FileStorage::READ);
-    ASSERT_TRUE(fs.isOpened());
-
-    ASSERT_TRUE(cascade.load(fs.getFirstTopLevelNode()));
-}
-
-typedef ::testing::TestWithParam<cv::gpu::DeviceInfo > SCascadeTestAll;
-GPU_TEST_P(SCascadeTestAll, detect,
-        ALL_DEVICES
-        )
+GPU_TEST_P(SCascadeTestAll, detect)
 {
-    cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
 
@@ -239,20 +235,16 @@ GPU_TEST_P(SCascadeTestAll, detect,
     GpuMat sub(rois, cv::Rect(rois.cols / 4, rois.rows / 4,rois.cols / 2, rois.rows / 2));
     sub.setTo(cv::Scalar::all(1));
 
-    objectBoxes.setTo(0);
     cascade.detect(colored, rois, objectBoxes);
 
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2448);
+    ASSERT_EQ(a, 2448);
 }
 
-GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
-        ALL_DEVICES
-        )
+GPU_TEST_P(SCascadeTestAll, detectOnIntegral)
 {
-    cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
 
@@ -283,15 +275,11 @@ GPU_TEST_P(SCascadeTestAll, detectOnIntegral,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-
-    ASSERT_EQ( a ,1024);
+    ASSERT_EQ(a, 1024);
 }
 
-GPU_TEST_P(SCascadeTestAll, detectStream,
-        ALL_DEVICES
-        )
+GPU_TEST_P(SCascadeTestAll, detectStream)
 {
-    cv::gpu::setDevice(GetParam().deviceID());
     std::string xml =  cvtest::TS::ptr()->get_data_path() + "../cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml";
     cv::gpu::SCascade cascade;
 
@@ -318,8 +306,9 @@ GPU_TEST_P(SCascadeTestAll, detectStream,
     typedef cv::gpu::SCascade::Detection Detection;
     cv::Mat detections(objectBoxes);
     int a = *(detections.ptr<int>(0));
-    ASSERT_EQ(a ,2448);
+    ASSERT_EQ(a, 2448);
 }
 
+INSTANTIATE_TEST_CASE_P(GPU_SoftCascade, SCascadeTestAll, ALL_DEVICES);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/modules/gpu/test/test_threshold.cpp b/modules/gpu/test/test_threshold.cpp
index c56921045..43e651ad8 100644
--- a/modules/gpu/test/test_threshold.cpp
+++ b/modules/gpu/test/test_threshold.cpp
@@ -66,7 +66,7 @@ PARAM_TEST_CASE(Threshold, cv::gpu::DeviceInfo, cv::Size, MatType, ThreshOp, Use
     }
 };
 
-TEST_P(Threshold, Accuracy)
+GPU_TEST_P(Threshold, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     double maxVal = randomDouble(20.0, 127.0);
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index c56e3d2eb..4cbbf0bf8 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -43,946 +43,6 @@
 
 #ifdef HAVE_CUDA
 
-//#define DUMP
-
-//////////////////////////////////////////////////////
-// BroxOpticalFlow
-
-#define BROX_OPTICAL_FLOW_DUMP_FILE            "opticalflow/brox_optical_flow.bin"
-#define BROX_OPTICAL_FLOW_DUMP_FILE_CC20       "opticalflow/brox_optical_flow_cc20.bin"
-
-struct BroxOpticalFlow : testing::TestWithParam<cv::gpu::DeviceInfo>
-{
-    cv::gpu::DeviceInfo devInfo;
-
-    virtual void SetUp()
-    {
-        devInfo = GetParam();
-
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
-
-TEST_P(BroxOpticalFlow, Regression)
-{
-    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                  10 /*inner_iterations*/, 77 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
-    brox(loadMat(frame0), loadMat(frame1), u, v);
-
-#ifndef DUMP
-    std::string fname(cvtest::TS::ptr()->get_data_path());
-    if (devInfo.majorVersion() >= 2)
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-    else
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
-
-    std::ifstream f(fname.c_str(), std::ios_base::binary);
-
-    int rows, cols;
-
-    f.read((char*)&rows, sizeof(rows));
-    f.read((char*)&cols, sizeof(cols));
-
-    cv::Mat u_gold(rows, cols, CV_32FC1);
-
-    for (int i = 0; i < u_gold.rows; ++i)
-        f.read(u_gold.ptr<char>(i), u_gold.cols * sizeof(float));
-
-    cv::Mat v_gold(rows, cols, CV_32FC1);
-
-    for (int i = 0; i < v_gold.rows; ++i)
-        f.read(v_gold.ptr<char>(i), v_gold.cols * sizeof(float));
-
-    EXPECT_MAT_NEAR(u_gold, u, 0);
-    EXPECT_MAT_NEAR(v_gold, v, 0);
-#else
-    std::string fname(cvtest::TS::ptr()->get_data_path());
-    if (devInfo.majorVersion() >= 2)
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE_CC20;
-    else
-        fname += BROX_OPTICAL_FLOW_DUMP_FILE;
-
-    std::ofstream f(fname.c_str(), std::ios_base::binary);
-
-    f.write((char*)&u.rows, sizeof(u.rows));
-    f.write((char*)&u.cols, sizeof(u.cols));
-
-    cv::Mat h_u(u);
-    cv::Mat h_v(v);
-
-    for (int i = 0; i < u.rows; ++i)
-        f.write(h_u.ptr<char>(i), u.cols * sizeof(float));
-
-    for (int i = 0; i < v.rows; ++i)
-        f.write(h_v.ptr<char>(i), v.cols * sizeof(float));
-
-#endif
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, BroxOpticalFlow, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// GoodFeaturesToTrack
-
-IMPLEMENT_PARAM_CLASS(MinDistance, double)
-
-PARAM_TEST_CASE(GoodFeaturesToTrack, cv::gpu::DeviceInfo, MinDistance)
-{
-    cv::gpu::DeviceInfo devInfo;
-    double minDistance;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        minDistance = GET_PARAM(1);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
-
-TEST_P(GoodFeaturesToTrack, Accuracy)
-{
-    cv::Mat image = readImage("opticalflow/frame0.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(image.empty());
-
-    int maxCorners = 1000;
-    double qualityLevel = 0.01;
-
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
-
-    if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
-    {
-        try
-        {
-            cv::gpu::GpuMat d_pts;
-            detector(loadMat(image), d_pts);
-        }
-        catch (const cv::Exception& e)
-        {
-            ASSERT_EQ(CV_StsNotImplemented, e.code);
-        }
-    }
-    else
-    {
-        cv::gpu::GpuMat d_pts;
-        detector(loadMat(image), d_pts);
-
-        std::vector<cv::Point2f> pts(d_pts.cols);
-        cv::Mat pts_mat(1, d_pts.cols, CV_32FC2, (void*)&pts[0]);
-        d_pts.download(pts_mat);
-
-        std::vector<cv::Point2f> pts_gold;
-        cv::goodFeaturesToTrack(image, pts_gold, maxCorners, qualityLevel, minDistance);
-
-        ASSERT_EQ(pts_gold.size(), pts.size());
-
-        size_t mistmatch = 0;
-        for (size_t i = 0; i < pts.size(); ++i)
-        {
-            cv::Point2i a = pts_gold[i];
-            cv::Point2i b = pts[i];
-
-            bool eq = std::abs(a.x - b.x) < 1 && std::abs(a.y - b.y) < 1;
-
-            if (!eq)
-                ++mistmatch;
-        }
-
-        double bad_ratio = static_cast<double>(mistmatch) / pts.size();
-
-        ASSERT_LE(bad_ratio, 0.01);
-    }
-}
-
-TEST_P(GoodFeaturesToTrack, EmptyCorners)
-{
-    int maxCorners = 1000;
-    double qualityLevel = 0.01;
-
-    cv::gpu::GoodFeaturesToTrackDetector_GPU detector(maxCorners, qualityLevel, minDistance);
-
-    cv::gpu::GpuMat src(100, 100, CV_8UC1, cv::Scalar::all(0));
-    cv::gpu::GpuMat corners(1, maxCorners, CV_32FC2);
-
-    detector(src, corners);
-
-    ASSERT_TRUE( corners.empty() );
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, GoodFeaturesToTrack, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(MinDistance(0.0), MinDistance(3.0))));
-
-//////////////////////////////////////////////////////
-// PyrLKOpticalFlow
-
-IMPLEMENT_PARAM_CLASS(UseGray, bool)
-
-PARAM_TEST_CASE(PyrLKOpticalFlow, cv::gpu::DeviceInfo, UseGray)
-{
-    cv::gpu::DeviceInfo devInfo;
-    bool useGray;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        useGray = GET_PARAM(1);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
-
-TEST_P(PyrLKOpticalFlow, Sparse)
-{
-    cv::Mat frame0 = readImage("opticalflow/frame0.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/frame1.png", useGray ? cv::IMREAD_GRAYSCALE : cv::IMREAD_COLOR);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Mat gray_frame;
-    if (useGray)
-        gray_frame = frame0;
-    else
-        cv::cvtColor(frame0, gray_frame, cv::COLOR_BGR2GRAY);
-
-    std::vector<cv::Point2f> pts;
-    cv::goodFeaturesToTrack(gray_frame, pts, 1000, 0.01, 0.0);
-
-    cv::gpu::GpuMat d_pts;
-    cv::Mat pts_mat(1, (int)pts.size(), CV_32FC2, (void*)&pts[0]);
-    d_pts.upload(pts_mat);
-
-    cv::gpu::PyrLKOpticalFlow pyrLK;
-
-    cv::gpu::GpuMat d_nextPts;
-    cv::gpu::GpuMat d_status;
-    pyrLK.sparse(loadMat(frame0), loadMat(frame1), d_pts, d_nextPts, d_status);
-
-    std::vector<cv::Point2f> nextPts(d_nextPts.cols);
-    cv::Mat nextPts_mat(1, d_nextPts.cols, CV_32FC2, (void*)&nextPts[0]);
-    d_nextPts.download(nextPts_mat);
-
-    std::vector<unsigned char> status(d_status.cols);
-    cv::Mat status_mat(1, d_status.cols, CV_8UC1, (void*)&status[0]);
-    d_status.download(status_mat);
-
-    std::vector<cv::Point2f> nextPts_gold;
-    std::vector<unsigned char> status_gold;
-    cv::calcOpticalFlowPyrLK(frame0, frame1, pts, nextPts_gold, status_gold, cv::noArray());
-
-    ASSERT_EQ(nextPts_gold.size(), nextPts.size());
-    ASSERT_EQ(status_gold.size(), status.size());
-
-    size_t mistmatch = 0;
-    for (size_t i = 0; i < nextPts.size(); ++i)
-    {
-        cv::Point2i a = nextPts[i];
-        cv::Point2i b = nextPts_gold[i];
-
-        if (status[i] != status_gold[i])
-        {
-            ++mistmatch;
-            continue;
-        }
-
-        if (status[i])
-        {
-            bool eq = std::abs(a.x - b.x) <= 1 && std::abs(a.y - b.y) <= 1;
-
-            if (!eq)
-                ++mistmatch;
-        }
-    }
-
-    double bad_ratio = static_cast<double>(mistmatch) / nextPts.size();
-
-    ASSERT_LE(bad_ratio, 0.01);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, PyrLKOpticalFlow, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(UseGray(true), UseGray(false))));
-
-//////////////////////////////////////////////////////
-// FarnebackOpticalFlow
-
-IMPLEMENT_PARAM_CLASS(PyrScale, double)
-IMPLEMENT_PARAM_CLASS(PolyN, int)
-CV_FLAGS(FarnebackOptFlowFlags, 0, cv::OPTFLOW_FARNEBACK_GAUSSIAN)
-IMPLEMENT_PARAM_CLASS(UseInitFlow, bool)
-
-PARAM_TEST_CASE(FarnebackOpticalFlow, cv::gpu::DeviceInfo, PyrScale, PolyN, FarnebackOptFlowFlags, UseInitFlow)
-{
-    cv::gpu::DeviceInfo devInfo;
-    double pyrScale;
-    int polyN;
-    int flags;
-    bool useInitFlow;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        pyrScale = GET_PARAM(1);
-        polyN = GET_PARAM(2);
-        flags = GET_PARAM(3);
-        useInitFlow = GET_PARAM(4);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-    }
-};
-
-TEST_P(FarnebackOpticalFlow, Accuracy)
-{
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    double polySigma = polyN <= 5 ? 1.1 : 1.5;
-
-    cv::gpu::FarnebackOpticalFlow calc;
-    calc.pyrScale = pyrScale;
-    calc.polyN = polyN;
-    calc.polySigma = polySigma;
-    calc.flags = flags;
-
-    cv::gpu::GpuMat d_flowx, d_flowy;
-    calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-
-    cv::Mat flow;
-    if (useInitFlow)
-    {
-        cv::Mat flowxy[] = {cv::Mat(d_flowx), cv::Mat(d_flowy)};
-        cv::merge(flowxy, 2, flow);
-    }
-
-    if (useInitFlow)
-    {
-        calc.flags |= cv::OPTFLOW_USE_INITIAL_FLOW;
-        calc(loadMat(frame0), loadMat(frame1), d_flowx, d_flowy);
-    }
-
-    cv::calcOpticalFlowFarneback(
-        frame0, frame1, flow, calc.pyrScale, calc.numLevels, calc.winSize,
-        calc.numIters,  calc.polyN, calc.polySigma, calc.flags);
-
-    std::vector<cv::Mat> flowxy;
-    cv::split(flow, flowxy);
-
-    EXPECT_MAT_SIMILAR(flowxy[0], d_flowx, 0.1);
-    EXPECT_MAT_SIMILAR(flowxy[1], d_flowy, 0.1);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, FarnebackOpticalFlow, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(PyrScale(0.3), PyrScale(0.5), PyrScale(0.8)),
-    testing::Values(PolyN(5), PolyN(7)),
-    testing::Values(FarnebackOptFlowFlags(0), FarnebackOptFlowFlags(cv::OPTFLOW_FARNEBACK_GAUSSIAN)),
-    testing::Values(UseInitFlow(false), UseInitFlow(true))));
-
-struct OpticalFlowNan : public BroxOpticalFlow {};
-
-TEST_P(OpticalFlowNan, Regression)
-{
-    cv::Mat frame0 = readImageType("opticalflow/frame0.png", CV_32FC1);
-    ASSERT_FALSE(frame0.empty());
-    cv::Mat r_frame0, r_frame1;
-    cv::resize(frame0, r_frame0, cv::Size(1380,1000));
-
-    cv::Mat frame1 = readImageType("opticalflow/frame1.png", CV_32FC1);
-    ASSERT_FALSE(frame1.empty());
-    cv::resize(frame1, r_frame1, cv::Size(1380,1000));
-
-    cv::gpu::BroxOpticalFlow brox(0.197f /*alpha*/, 50.0f /*gamma*/, 0.8f /*scale_factor*/,
-                                  5 /*inner_iterations*/, 150 /*outer_iterations*/, 10 /*solver_iterations*/);
-
-    cv::gpu::GpuMat u;
-    cv::gpu::GpuMat v;
-    brox(loadMat(r_frame0), loadMat(r_frame1), u, v);
-
-    cv::Mat h_u, h_v;
-    u.download(h_u);
-    v.download(h_v);
-    EXPECT_TRUE(cv::checkRange(h_u));
-    EXPECT_TRUE(cv::checkRange(h_v));
-};
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowNan, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// OpticalFlowDual_TVL1
-
-PARAM_TEST_CASE(OpticalFlowDual_TVL1, cv::gpu::DeviceInfo, UseRoi)
-{
-};
-
-TEST_P(OpticalFlowDual_TVL1, Accuracy)
-{
-    cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    const bool useRoi = GET_PARAM(1);
-
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::gpu::OpticalFlowDual_TVL1_GPU d_alg;
-    cv::gpu::GpuMat d_flowx = createMat(frame0.size(), CV_32FC1, useRoi);
-    cv::gpu::GpuMat d_flowy = createMat(frame0.size(), CV_32FC1, useRoi);
-    d_alg(loadMat(frame0, useRoi), loadMat(frame1, useRoi), d_flowx, d_flowy);
-
-    cv::OpticalFlowDual_TVL1 alg;
-    cv::Mat flow;
-    alg(frame0, frame1, flow);
-    cv::Mat gold[2];
-    cv::split(flow, gold);
-
-    EXPECT_MAT_SIMILAR(gold[0], d_flowx, 3e-3);
-    EXPECT_MAT_SIMILAR(gold[1], d_flowy, 3e-3);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowDual_TVL1, testing::Combine(
-    ALL_DEVICES,
-    WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////
-// OpticalFlowBM
-
-void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
-                       cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
-                       cv::Mat& velx, cv::Mat& vely)
-{
-    cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
-
-    velx.create(sz, CV_32FC1);
-    vely.create(sz, CV_32FC1);
-
-    CvMat cvprev = prev;
-    CvMat cvcurr = curr;
-
-    CvMat cvvelx = velx;
-    CvMat cvvely = vely;
-
-    cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
-}
-
-struct OpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
-{
-};
-
-TEST_P(OpticalFlowBM, Accuracy)
-{
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Size block_size(16, 16);
-    cv::Size shift_size(1, 1);
-    cv::Size max_range(16, 16);
-
-    cv::gpu::GpuMat d_velx, d_vely, buf;
-    cv::gpu::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
-                               block_size, shift_size, max_range, false,
-                               d_velx, d_vely, buf);
-
-    cv::Mat velx, vely;
-    calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
-
-    EXPECT_MAT_NEAR(velx, d_velx, 0);
-    EXPECT_MAT_NEAR(vely, d_vely, 0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, OpticalFlowBM, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// FastOpticalFlowBM
-
-static void FastOpticalFlowBM_gold(const cv::Mat_<uchar>& I0, const cv::Mat_<uchar>& I1, cv::Mat_<float>& velx, cv::Mat_<float>& vely, int search_window, int block_window)
-{
-    velx.create(I0.size());
-    vely.create(I0.size());
-
-    int search_radius = search_window / 2;
-    int block_radius = block_window / 2;
-
-    for (int y = 0; y < I0.rows; ++y)
-    {
-        for (int x = 0; x < I0.cols; ++x)
-        {
-            int bestDist = std::numeric_limits<int>::max();
-            int bestDx = 0;
-            int bestDy = 0;
-
-            for (int dy = -search_radius; dy <= search_radius; ++dy)
-            {
-                for (int dx = -search_radius; dx <= search_radius; ++dx)
-                {
-                    int dist = 0;
-
-                    for (int by = -block_radius; by <= block_radius; ++by)
-                    {
-                        for (int bx = -block_radius; bx <= block_radius; ++bx)
-                        {
-                            int I0_val = I0(cv::borderInterpolate(y + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + bx, I0.cols, cv::BORDER_DEFAULT));
-                            int I1_val = I1(cv::borderInterpolate(y + dy + by, I0.rows, cv::BORDER_DEFAULT), cv::borderInterpolate(x + dx + bx, I0.cols, cv::BORDER_DEFAULT));
-
-                            dist += std::abs(I0_val - I1_val);
-                        }
-                    }
-
-                    if (dist < bestDist)
-                    {
-                        bestDist = dist;
-                        bestDx = dx;
-                        bestDy = dy;
-                    }
-                }
-            }
-
-            velx(y, x) = (float) bestDx;
-            vely(y, x) = (float) bestDy;
-        }
-    }
-}
-
-static double calc_rmse(const cv::Mat_<float>& flow1, const cv::Mat_<float>& flow2)
-{
-    double sum = 0.0;
-
-    for (int y = 0; y < flow1.rows; ++y)
-    {
-        for (int x = 0; x < flow1.cols; ++x)
-        {
-            double diff = flow1(y, x) - flow2(y, x);
-            sum += diff * diff;
-        }
-    }
-
-    return std::sqrt(sum / flow1.size().area());
-}
-
-struct FastOpticalFlowBM : testing::TestWithParam<cv::gpu::DeviceInfo>
-{
-};
-
-TEST_P(FastOpticalFlowBM, Accuracy)
-{
-    const double MAX_RMSE = 0.6;
-
-    int search_window = 15;
-    int block_window = 5;
-
-    cv::gpu::DeviceInfo devInfo = GetParam();
-    cv::gpu::setDevice(devInfo.deviceID());
-
-    cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame0.empty());
-
-    cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
-    ASSERT_FALSE(frame1.empty());
-
-    cv::Size smallSize(320, 240);
-    cv::Mat frame0_small;
-    cv::Mat frame1_small;
-
-    cv::resize(frame0, frame0_small, smallSize);
-    cv::resize(frame1, frame1_small, smallSize);
-
-    cv::gpu::GpuMat d_flowx;
-    cv::gpu::GpuMat d_flowy;
-    cv::gpu::FastOpticalFlowBM fastBM;
-
-    fastBM(loadMat(frame0_small), loadMat(frame1_small), d_flowx, d_flowy, search_window, block_window);
-
-    cv::Mat_<float> flowx;
-    cv::Mat_<float> flowy;
-    FastOpticalFlowBM_gold(frame0_small, frame1_small, flowx, flowy, search_window, block_window);
-
-    double err;
-
-    err = calc_rmse(flowx, cv::Mat(d_flowx));
-    EXPECT_LE(err, MAX_RMSE);
-
-    err = calc_rmse(flowy, cv::Mat(d_flowy));
-    EXPECT_LE(err, MAX_RMSE);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, FastOpticalFlowBM, ALL_DEVICES);
-
-//////////////////////////////////////////////////////
-// FGDStatModel
-
-namespace cv
-{
-    template<> void Ptr<CvBGStatModel>::delete_obj()
-    {
-        cvReleaseBGStatModel(&obj);
-    }
-}
-
-PARAM_TEST_CASE(FGDStatModel, cv::gpu::DeviceInfo, std::string, Channels)
-{
-    cv::gpu::DeviceInfo devInfo;
-    std::string inputFile;
-    int out_cn;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
-
-        out_cn = GET_PARAM(2);
-    }
-};
-
-TEST_P(FGDStatModel, Update)
-{
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    IplImage ipl_frame = frame;
-    cv::Ptr<CvBGStatModel> model(cvCreateFGDStatModel(&ipl_frame));
-
-    cv::gpu::GpuMat d_frame(frame);
-    cv::gpu::FGDStatModel d_model(out_cn);
-    d_model.create(d_frame);
-
-    cv::Mat h_background;
-    cv::Mat h_foreground;
-    cv::Mat h_background3;
-
-    cv::Mat backgroundDiff;
-    cv::Mat foregroundDiff;
-
-    for (int i = 0; i < 5; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        ipl_frame = frame;
-        int gold_count = cvUpdateBGStatModel(&ipl_frame, model);
-
-        d_frame.upload(frame);
-
-        int count = d_model.update(d_frame);
-
-        ASSERT_EQ(gold_count, count);
-
-        cv::Mat gold_background(model->background);
-        cv::Mat gold_foreground(model->foreground);
-
-        if (out_cn == 3)
-            d_model.background.download(h_background3);
-        else
-        {
-            d_model.background.download(h_background);
-            cv::cvtColor(h_background, h_background3, cv::COLOR_BGRA2BGR);
-        }
-        d_model.foreground.download(h_foreground);
-
-        ASSERT_MAT_NEAR(gold_background, h_background3, 1.0);
-        ASSERT_MAT_NEAR(gold_foreground, h_foreground, 0.0);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, FGDStatModel, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi")),
-    testing::Values(Channels(3), Channels(4))));
-
-//////////////////////////////////////////////////////
-// MOG
-
-IMPLEMENT_PARAM_CLASS(LearningRate, double)
-
-PARAM_TEST_CASE(MOG, cv::gpu::DeviceInfo, std::string, UseGray, LearningRate, UseRoi)
-{
-    cv::gpu::DeviceInfo devInfo;
-    std::string inputFile;
-    bool useGray;
-    double learningRate;
-    bool useRoi;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
-
-        useGray = GET_PARAM(2);
-
-        learningRate = GET_PARAM(3);
-
-        useRoi = GET_PARAM(4);
-    }
-};
-
-TEST_P(MOG, Update)
-{
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    cv::gpu::MOG_GPU mog;
-    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-    cv::BackgroundSubtractorMOG mog_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (useGray)
-        {
-            cv::Mat temp;
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            cv::swap(temp, frame);
-        }
-
-        mog(loadMat(frame, useRoi), foreground, (float)learningRate);
-
-        mog_gold(frame, foreground_gold, learningRate);
-
-        ASSERT_MAT_NEAR(foreground_gold, foreground, 0.0);
-    }
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, MOG, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi")),
-    testing::Values(UseGray(true), UseGray(false)),
-    testing::Values(LearningRate(0.0), LearningRate(0.01)),
-    WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////
-// MOG2
-
-PARAM_TEST_CASE(MOG2, cv::gpu::DeviceInfo, std::string, UseGray, UseRoi)
-{
-    cv::gpu::DeviceInfo devInfo;
-    std::string inputFile;
-    bool useGray;
-    bool useRoi;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + GET_PARAM(1);
-
-        useGray = GET_PARAM(2);
-
-        useRoi = GET_PARAM(3);
-    }
-};
-
-TEST_P(MOG2, Update)
-{
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-    cap >> frame;
-    ASSERT_FALSE(frame.empty());
-
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground = createMat(frame.size(), CV_8UC1, useRoi);
-
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        if (useGray)
-        {
-            cv::Mat temp;
-            cv::cvtColor(frame, temp, cv::COLOR_BGR2GRAY);
-            cv::swap(temp, frame);
-        }
-
-        mog2(loadMat(frame, useRoi), foreground);
-
-        mog2_gold(frame, foreground_gold);
-
-        double norm = cv::norm(foreground_gold, cv::Mat(foreground), cv::NORM_L1);
-
-        norm /= foreground_gold.size().area();
-
-        ASSERT_LE(norm, 0.09);
-    }
-}
-
-TEST_P(MOG2, getBackgroundImage)
-{
-    if (useGray)
-        return;
-
-    cv::VideoCapture cap(inputFile);
-    ASSERT_TRUE(cap.isOpened());
-
-    cv::Mat frame;
-
-    cv::gpu::MOG2_GPU mog2;
-    cv::gpu::GpuMat foreground;
-
-    cv::BackgroundSubtractorMOG2 mog2_gold;
-    cv::Mat foreground_gold;
-
-    for (int i = 0; i < 10; ++i)
-    {
-        cap >> frame;
-        ASSERT_FALSE(frame.empty());
-
-        mog2(loadMat(frame, useRoi), foreground);
-
-        mog2_gold(frame, foreground_gold);
-    }
-
-    cv::gpu::GpuMat background = createMat(frame.size(), frame.type(), useRoi);
-    mog2.getBackgroundImage(background);
-
-    cv::Mat background_gold;
-    mog2_gold.getBackgroundImage(background_gold);
-
-    ASSERT_MAT_NEAR(background_gold, background, 0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, MOG2, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi")),
-    testing::Values(UseGray(true), UseGray(false)),
-    WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////
-// VIBE
-
-PARAM_TEST_CASE(VIBE, cv::gpu::DeviceInfo, cv::Size, MatType, UseRoi)
-{
-};
-
-TEST_P(VIBE, Accuracy)
-{
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const int type = GET_PARAM(2);
-    const bool useRoi = GET_PARAM(3);
-
-    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
-
-    cv::Mat frame = randomMat(size, type, 0.0, 100);
-    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
-
-    cv::gpu::VIBE_GPU vibe;
-    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-    vibe.initialize(d_frame);
-
-    for (int i = 0; i < 20; ++i)
-        vibe(d_frame, d_fgmask);
-
-    frame = randomMat(size, type, 160, 255);
-    d_frame = loadMat(frame, useRoi);
-    vibe(d_frame, d_fgmask);
-
-    // now fgmask should be entirely foreground
-    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, VIBE, testing::Combine(
-    ALL_DEVICES,
-    DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8UC1), MatType(CV_8UC3), MatType(CV_8UC4)),
-    WHOLE_SUBMAT));
-
-//////////////////////////////////////////////////////
-// GMG
-
-PARAM_TEST_CASE(GMG, cv::gpu::DeviceInfo, cv::Size, MatDepth, Channels, UseRoi)
-{
-};
-
-TEST_P(GMG, Accuracy)
-{
-    const cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
-    cv::gpu::setDevice(devInfo.deviceID());
-    const cv::Size size = GET_PARAM(1);
-    const int depth = GET_PARAM(2);
-    const int channels = GET_PARAM(3);
-    const bool useRoi = GET_PARAM(4);
-
-    const int type = CV_MAKE_TYPE(depth, channels);
-
-    const cv::Mat zeros(size, CV_8UC1, cv::Scalar::all(0));
-    const cv::Mat fullfg(size, CV_8UC1, cv::Scalar::all(255));
-
-    cv::Mat frame = randomMat(size, type, 0, 100);
-    cv::gpu::GpuMat d_frame = loadMat(frame, useRoi);
-
-    cv::gpu::GMG_GPU gmg;
-    gmg.numInitializationFrames = 5;
-    gmg.smoothingRadius = 0;
-    gmg.initialize(d_frame.size(), 0, 255);
-
-    cv::gpu::GpuMat d_fgmask = createMat(size, CV_8UC1, useRoi);
-
-    for (int i = 0; i < gmg.numInitializationFrames; ++i)
-    {
-        gmg(d_frame, d_fgmask);
-
-        // fgmask should be entirely background during training
-        ASSERT_MAT_NEAR(zeros, d_fgmask, 0);
-    }
-
-    frame = randomMat(size, type, 160, 255);
-    d_frame = loadMat(frame, useRoi);
-    gmg(d_frame, d_fgmask);
-
-    // now fgmask should be entirely foreground
-    ASSERT_MAT_NEAR(fullfg, d_fgmask, 0);
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, GMG, testing::Combine(
-    ALL_DEVICES,
-    DIFFERENT_SIZES,
-    testing::Values(MatType(CV_8U), MatType(CV_16U), MatType(CV_32F)),
-    testing::Values(Channels(1), Channels(3), Channels(4)),
-    WHOLE_SUBMAT));
-
 #ifdef WIN32
 
 //////////////////////////////////////////////////////
@@ -993,8 +53,6 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
     cv::gpu::DeviceInfo devInfo;
     std::string inputFile;
 
-    std::string outputFile;
-
     virtual void SetUp()
     {
         devInfo = GET_PARAM(0);
@@ -1002,17 +60,17 @@ PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 
         cv::gpu::setDevice(devInfo.deviceID());
 
-        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + inputFile;
-        outputFile = cv::tempfile(".avi");
+        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + std::string("video/") + inputFile;
     }
 };
 
-TEST_P(VideoWriter, Regression)
+GPU_TEST_P(VideoWriter, Regression)
 {
+    std::string outputFile = cv::tempfile(".avi");
     const double FPS = 25.0;
 
     cv::VideoCapture reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
+    ASSERT_TRUE(reader.isOpened());
 
     cv::gpu::VideoWriter_GPU d_writer;
 
@@ -1036,12 +94,12 @@ TEST_P(VideoWriter, Regression)
     d_writer.close();
 
     reader.open(outputFile);
-    ASSERT_TRUE( reader.isOpened() );
+    ASSERT_TRUE(reader.isOpened());
 
     for (int i = 0; i < 5; ++i)
     {
         reader >> frame;
-        ASSERT_FALSE( frame.empty() );
+        ASSERT_FALSE(frame.empty());
     }
 }
 
@@ -1068,21 +126,21 @@ PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
     }
 };
 
-TEST_P(VideoReader, Regression)
+GPU_TEST_P(VideoReader, Regression)
 {
     cv::gpu::VideoReader_GPU reader(inputFile);
-    ASSERT_TRUE( reader.isOpened() );
+    ASSERT_TRUE(reader.isOpened());
 
     cv::gpu::GpuMat frame;
 
     for (int i = 0; i < 10; ++i)
     {
-        ASSERT_TRUE( reader.read(frame) );
-        ASSERT_FALSE( frame.empty() );
+        ASSERT_TRUE(reader.read(frame));
+        ASSERT_FALSE(frame.empty());
     }
 
     reader.close();
-    ASSERT_FALSE( reader.isOpened() );
+    ASSERT_FALSE(reader.isOpened());
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
diff --git a/modules/gpu/test/test_warp_affine.cpp b/modules/gpu/test/test_warp_affine.cpp
index 065c6755e..de8bc5d79 100644
--- a/modules/gpu/test/test_warp_affine.cpp
+++ b/modules/gpu/test/test_warp_affine.cpp
@@ -48,6 +48,7 @@ namespace
     cv::Mat createTransfomMatrix(cv::Size srcSize, double angle)
     {
         cv::Mat M(2, 3, CV_64FC1);
+
         M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2;
         M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) =  std::cos(angle); M.at<double>(1, 2) = 0.0;
 
@@ -74,22 +75,23 @@ PARAM_TEST_CASE(BuildWarpAffineMaps, cv::gpu::DeviceInfo, cv::Size, Inverse)
     }
 };
 
-TEST_P(BuildWarpAffineMaps, Accuracy)
+GPU_TEST_P(BuildWarpAffineMaps, Accuracy)
 {
     cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
+
     cv::gpu::GpuMat xmap, ymap;
     cv::gpu::buildWarpAffineMaps(M, inverse, size, xmap, ymap);
 
     int interpolation = cv::INTER_NEAREST;
     int borderMode = cv::BORDER_CONSTANT;
-
-    cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-    cv::Mat dst;
-    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
-
     int flags = interpolation;
     if (inverse)
         flags |= cv::WARP_INVERSE_MAP;
+
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+
     cv::Mat dst_gold;
     cv::warpAffine(src, dst_gold, M, size, flags, borderMode);
 
@@ -199,7 +201,7 @@ PARAM_TEST_CASE(WarpAffine, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse, Int
     }
 };
 
-TEST_P(WarpAffine, Accuracy)
+GPU_TEST_P(WarpAffine, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
@@ -247,7 +249,7 @@ PARAM_TEST_CASE(WarpAffineNPP, cv::gpu::DeviceInfo, MatType, Inverse, Interpolat
     }
 };
 
-TEST_P(WarpAffineNPP, Accuracy)
+GPU_TEST_P(WarpAffineNPP, Accuracy)
 {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
diff --git a/modules/gpu/test/test_warp_perspective.cpp b/modules/gpu/test/test_warp_perspective.cpp
index 95c089bb9..534edc0d2 100644
--- a/modules/gpu/test/test_warp_perspective.cpp
+++ b/modules/gpu/test/test_warp_perspective.cpp
@@ -48,6 +48,7 @@ namespace
     cv::Mat createTransfomMatrix(cv::Size srcSize, double angle)
     {
         cv::Mat M(3, 3, CV_64FC1);
+
         M.at<double>(0, 0) = std::cos(angle); M.at<double>(0, 1) = -std::sin(angle); M.at<double>(0, 2) = srcSize.width / 2;
         M.at<double>(1, 0) = std::sin(angle); M.at<double>(1, 1) =  std::cos(angle); M.at<double>(1, 2) = 0.0;
         M.at<double>(2, 0) = 0.0            ; M.at<double>(2, 1) =  0.0            ; M.at<double>(2, 2) = 1.0;
@@ -75,21 +76,25 @@ PARAM_TEST_CASE(BuildWarpPerspectiveMaps, cv::gpu::DeviceInfo, cv::Size, Inverse
     }
 };
 
-TEST_P(BuildWarpPerspectiveMaps, Accuracy)
+GPU_TEST_P(BuildWarpPerspectiveMaps, Accuracy)
 {
     cv::Mat M = createTransfomMatrix(size, CV_PI / 4);
+
     cv::gpu::GpuMat xmap, ymap;
     cv::gpu::buildWarpPerspectiveMaps(M, inverse, size, xmap, ymap);
 
     cv::Mat src = randomMat(randomSize(200, 400), CV_8UC1);
-    cv::Mat dst;
-    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), cv::INTER_NEAREST, cv::BORDER_CONSTANT);
-
-    int flags = cv::INTER_NEAREST;
+    int interpolation = cv::INTER_NEAREST;
+    int borderMode = cv::BORDER_CONSTANT;
+    int flags = interpolation;
     if (inverse)
         flags |= cv::WARP_INVERSE_MAP;
+
+    cv::Mat dst;
+    cv::remap(src, dst, cv::Mat(xmap), cv::Mat(ymap), interpolation, borderMode);
+
     cv::Mat dst_gold;
-    cv::warpPerspective(src, dst_gold, M, size, flags, cv::BORDER_CONSTANT);
+    cv::warpPerspective(src, dst_gold, M, size, flags, borderMode);
 
     EXPECT_MAT_NEAR(dst_gold, dst, 0.0);
 }
@@ -199,7 +204,7 @@ PARAM_TEST_CASE(WarpPerspective, cv::gpu::DeviceInfo, cv::Size, MatType, Inverse
     }
 };
 
-TEST_P(WarpPerspective, Accuracy)
+GPU_TEST_P(WarpPerspective, Accuracy)
 {
     cv::Mat src = randomMat(size, type);
     cv::Mat M = createTransfomMatrix(size, CV_PI / 3);
@@ -247,7 +252,7 @@ PARAM_TEST_CASE(WarpPerspectiveNPP, cv::gpu::DeviceInfo, MatType, Inverse, Inter
     }
 };
 
-TEST_P(WarpPerspectiveNPP, Accuracy)
+GPU_TEST_P(WarpPerspectiveNPP, Accuracy)
 {
     cv::Mat src = readImageType("stereobp/aloe-L.png", type);
     cv::Mat M = createTransfomMatrix(src.size(), CV_PI / 4);
diff --git a/modules/gpu/test/utility.cpp b/modules/gpu/test/utility.cpp
index 2a4cebc8d..88f796324 100644
--- a/modules/gpu/test/utility.cpp
+++ b/modules/gpu/test/utility.cpp
@@ -67,7 +67,7 @@ double randomDouble(double minVal, double maxVal)
 
 Size randomSize(int minVal, int maxVal)
 {
-    return cv::Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal));
+    return Size(randomInt(minVal, maxVal), randomInt(minVal, maxVal));
 }
 
 Scalar randomScalar(double minVal, double maxVal)
@@ -83,7 +83,7 @@ Mat randomMat(Size size, int type, double minVal, double maxVal)
 //////////////////////////////////////////////////////////////////////
 // GpuMat create
 
-cv::gpu::GpuMat createMat(cv::Size size, int type, bool useRoi)
+GpuMat createMat(Size size, int type, bool useRoi)
 {
     Size size0 = size;
 
@@ -122,21 +122,13 @@ Mat readImageType(const std::string& fname, int type)
     if (CV_MAT_CN(type) == 4)
     {
         Mat temp;
-        cvtColor(src, temp, cv::COLOR_BGR2BGRA);
+        cvtColor(src, temp, COLOR_BGR2BGRA);
         swap(src, temp);
     }
     src.convertTo(src, CV_MAT_DEPTH(type), CV_MAT_DEPTH(type) == CV_32F ? 1.0 / 255.0 : 1.0);
     return src;
 }
 
-//////////////////////////////////////////////////////////////////////
-// Image dumping
-
-void dumpImage(const std::string& fileName, const cv::Mat& image)
-{
-    cv::imwrite(TS::ptr()->get_data_path() + fileName, image);
-}
-
 //////////////////////////////////////////////////////////////////////
 // Gpu devices
 
@@ -156,7 +148,7 @@ void DeviceManager::load(int i)
     devices_.clear();
     devices_.reserve(1);
 
-    ostringstream msg;
+    std::ostringstream msg;
 
     if (i < 0 || i >= getCudaEnabledDeviceCount())
     {
@@ -195,21 +187,39 @@ void DeviceManager::loadAll()
 //////////////////////////////////////////////////////////////////////
 // Additional assertion
 
-Mat getMat(InputArray arr)
+namespace
 {
-    if (arr.kind() == _InputArray::GPU_MAT)
+    template <typename T, typename OutT> std::string printMatValImpl(const Mat& m, Point p)
     {
-        Mat m;
-        arr.getGpuMat().download(m);
-        return m;
+        const int cn = m.channels();
+
+        std::ostringstream ostr;
+        ostr << "(";
+
+        p.x /= cn;
+
+        ostr << static_cast<OutT>(m.at<T>(p.y, p.x * cn));
+        for (int c = 1; c < m.channels(); ++c)
+        {
+            ostr << ", " << static_cast<OutT>(m.at<T>(p.y, p.x * cn + c));
+        }
+        ostr << ")";
+
+        return ostr.str();
     }
 
-    return arr.getMat();
-}
+    std::string printMatVal(const Mat& m, Point p)
+    {
+        typedef std::string (*func_t)(const Mat& m, Point p);
 
-double checkNorm(InputArray m1, InputArray m2)
-{
-    return norm(getMat(m1), getMat(m2), NORM_INF);
+        static const func_t funcs[] =
+        {
+            printMatValImpl<uchar, int>, printMatValImpl<schar, int>, printMatValImpl<ushort, int>, printMatValImpl<short, int>,
+            printMatValImpl<int, int>, printMatValImpl<float, float>, printMatValImpl<double, double>
+        };
+
+        return funcs[m.depth()](m, p);
+    }
 }
 
 void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minLoc_, Point* maxLoc_, const Mat& mask)
@@ -229,8 +239,8 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL
 
     for (int y = 0; y < src.rows; ++y)
     {
-        const schar* src_row = src.ptr<signed char>(y);
-        const uchar* mask_row = mask.empty() ? 0 : mask.ptr<unsigned char>(y);
+        const schar* src_row = src.ptr<schar>(y);
+        const uchar* mask_row = mask.empty() ? 0 : mask.ptr<uchar>(y);
 
         for (int x = 0; x < src.cols; ++x)
         {
@@ -260,42 +270,19 @@ void minMaxLocGold(const Mat& src, double* minVal_, double* maxVal_, Point* minL
     if (maxLoc_) *maxLoc_ = maxLoc;
 }
 
-namespace
+Mat getMat(InputArray arr)
 {
-    template <typename T, typename OutT> std::string printMatValImpl(const Mat& m, Point p)
+    if (arr.kind() == _InputArray::GPU_MAT)
     {
-        const int cn = m.channels();
-
-        ostringstream ostr;
-        ostr << "(";
-
-        p.x /= cn;
-
-        ostr << static_cast<OutT>(m.at<T>(p.y, p.x * cn));
-        for (int c = 1; c < m.channels(); ++c)
-        {
-            ostr << ", " << static_cast<OutT>(m.at<T>(p.y, p.x * cn + c));
-        }
-        ostr << ")";
-
-        return ostr.str();
+        Mat m;
+        arr.getGpuMat().download(m);
+        return m;
     }
 
-    std::string printMatVal(const Mat& m, Point p)
-    {
-        typedef std::string (*func_t)(const Mat& m, Point p);
-
-        static const func_t funcs[] =
-        {
-            printMatValImpl<uchar, int>, printMatValImpl<schar, int>, printMatValImpl<ushort, int>, printMatValImpl<short, int>,
-            printMatValImpl<int, int>, printMatValImpl<float, float>, printMatValImpl<double, double>
-        };
-
-        return funcs[m.depth()](m, p);
-    }
+    return arr.getMat();
 }
 
-testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1_, cv::InputArray m2_, double eps)
+AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, InputArray m1_, InputArray m2_, double eps)
 {
     Mat m1 = getMat(m1_);
     Mat m2 = getMat(m2_);
@@ -344,18 +331,6 @@ double checkSimilarity(InputArray m1, InputArray m2)
 //////////////////////////////////////////////////////////////////////
 // Helper structs for value-parameterized tests
 
-vector<MatDepth> depths(int depth_start, int depth_end)
-{
-    vector<MatDepth> v;
-
-    v.reserve((depth_end - depth_start + 1));
-
-    for (int depth = depth_start; depth <= depth_end; ++depth)
-        v.push_back(depth);
-
-    return v;
-}
-
 vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
 {
     vector<MatType> v;
@@ -366,7 +341,7 @@ vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end)
     {
         for (int cn = cn_start; cn <= cn_end; ++cn)
         {
-            v.push_back(CV_MAKETYPE(depth, cn));
+            v.push_back(MatType(CV_MAKE_TYPE(depth, cn)));
         }
     }
 
@@ -401,6 +376,14 @@ void PrintTo(const Inverse& inverse, std::ostream* os)
         (*os) << "direct";
 }
 
+//////////////////////////////////////////////////////////////////////
+// Other
+
+void dumpImage(const std::string& fileName, const Mat& image)
+{
+    imwrite(TS::ptr()->get_data_path() + fileName, image);
+}
+
 void showDiff(InputArray gold_, InputArray actual_, double eps)
 {
     Mat gold = getMat(gold_);
diff --git a/modules/gpu/test/utility.hpp b/modules/gpu/test/utility.hpp
index a32aabea5..674e9a17e 100644
--- a/modules/gpu/test/utility.hpp
+++ b/modules/gpu/test/utility.hpp
@@ -39,8 +39,14 @@
 //
 //M*/
 
-#ifndef __OPENCV_TEST_UTILITY_HPP__
-#define __OPENCV_TEST_UTILITY_HPP__
+#ifndef __OPENCV_GPU_TEST_UTILITY_HPP__
+#define __OPENCV_GPU_TEST_UTILITY_HPP__
+
+#include "opencv2/core/core.hpp"
+#include "opencv2/core/gpumat.hpp"
+#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/ts/ts.hpp"
+#include "opencv2/ts/ts_perf.hpp"
 
 //////////////////////////////////////////////////////////////////////
 // random generators
@@ -66,11 +72,6 @@ cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
 //! read image from testdata folder and convert it to specified type
 cv::Mat readImageType(const std::string& fname, int type);
 
-//////////////////////////////////////////////////////////////////////
-// Image dumping
-
-void dumpImage(const std::string& fileName, const cv::Mat& image);
-
 //////////////////////////////////////////////////////////////////////
 // Gpu devices
 
@@ -96,12 +97,10 @@ private:
 //////////////////////////////////////////////////////////////////////
 // Additional assertion
 
-cv::Mat getMat(cv::InputArray arr);
-
-double checkNorm(cv::InputArray m1, cv::InputArray m2);
-
 void minMaxLocGold(const cv::Mat& src, double* minVal_, double* maxVal_ = 0, cv::Point* minLoc_ = 0, cv::Point* maxLoc_ = 0, const cv::Mat& mask = cv::Mat());
 
+cv::Mat getMat(cv::InputArray arr);
+
 testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1, cv::InputArray m2, double eps);
 
 #define EXPECT_MAT_NEAR(m1, m2, eps) EXPECT_PRED_FORMAT3(assertMatNear, m1, m2, eps)
@@ -164,6 +163,45 @@ double checkSimilarity(cv::InputArray m1, cv::InputArray m2);
 //////////////////////////////////////////////////////////////////////
 // Helper structs for value-parameterized tests
 
+#define GPU_TEST_P(test_case_name, test_name) \
+  class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
+      : public test_case_name { \
+   public: \
+    GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
+    virtual void TestBody(); \
+   private: \
+    void UnsafeTestBody(); \
+    static int AddToRegistry() { \
+      ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+          GetTestCasePatternHolder<test_case_name>(\
+              #test_case_name, __FILE__, __LINE__)->AddTestPattern(\
+                  #test_case_name, \
+                  #test_name, \
+                  new ::testing::internal::TestMetaFactory< \
+                      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
+      return 0; \
+    } \
+    static int gtest_registering_dummy_; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(\
+        GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
+  }; \
+  int GTEST_TEST_CLASS_NAME_(test_case_name, \
+                             test_name)::gtest_registering_dummy_ = \
+      GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
+  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() \
+  { \
+    try \
+    { \
+      UnsafeTestBody(); \
+    } \
+    catch (...) \
+    { \
+      cv::gpu::resetDevice(); \
+      throw; \
+    } \
+  } \
+  void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::UnsafeTestBody()
+
 #define PARAM_TEST_CASE(name, ...) struct name : testing::TestWithParam< std::tr1::tuple< __VA_ARGS__ > >
 #define GET_PARAM(k) std::tr1::get< k >(GetParam())
 
@@ -178,11 +216,8 @@ namespace cv { namespace gpu
 
 using perf::MatDepth;
 
-//! return vector with depths from specified range.
-std::vector<MatDepth> depths(int depth_start, int depth_end);
-
 #define ALL_DEPTH testing::Values(MatDepth(CV_8U), MatDepth(CV_8S), MatDepth(CV_16U), MatDepth(CV_16S), MatDepth(CV_32S), MatDepth(CV_32F), MatDepth(CV_64F))
-#define DEPTHS(depth_start, depth_end) testing::ValuesIn(depths(depth_start, depth_end))
+
 #define DEPTH_PAIRS testing::Values(std::make_pair(MatDepth(CV_8U), MatDepth(CV_8U)),   \
                                     std::make_pair(MatDepth(CV_8U), MatDepth(CV_16U)),  \
                                     std::make_pair(MatDepth(CV_8U), MatDepth(CV_16S)),  \
@@ -237,8 +272,6 @@ private:
 
 void PrintTo(const UseRoi& useRoi, std::ostream* os);
 
-#define WHOLE testing::Values(UseRoi(false))
-#define SUBMAT testing::Values(UseRoi(true))
 #define WHOLE_SUBMAT testing::Values(UseRoi(false), UseRoi(true))
 
 // Direct/Inverse
@@ -253,7 +286,9 @@ public:
 private:
     bool val_;
 };
+
 void PrintTo(const Inverse& useRoi, std::ostream* os);
+
 #define DIRECT_INVERSE testing::Values(Inverse(false), Inverse(true))
 
 // Param class
@@ -291,6 +326,7 @@ CV_FLAGS(WarpFlags, cv::INTER_NEAREST, cv::INTER_LINEAR, cv::INTER_CUBIC, cv::WA
 //////////////////////////////////////////////////////////////////////
 // Other
 
+void dumpImage(const std::string& fileName, const cv::Mat& image);
 void showDiff(cv::InputArray gold, cv::InputArray actual, double eps);
 
-#endif // __OPENCV_TEST_UTILITY_HPP__
+#endif // __OPENCV_GPU_TEST_UTILITY_HPP__

From 660d23aa0456d4f5dc5b0c7429bd38db37b84381 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Wed, 19 Dec 2012 16:44:34 +0400
Subject: [PATCH 151/155] added cv::gpu::resetDevice to RunPerfTestBody

---
 modules/gpu/perf/perf_softcascade.cpp | 21 ++++++++-------------
 modules/ts/include/opencv2/ts/ts.hpp  |  2 +-
 modules/ts/src/ts_perf.cpp            |  8 ++++++++
 3 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/modules/gpu/perf/perf_softcascade.cpp b/modules/gpu/perf/perf_softcascade.cpp
index 9645beeaf..e9437d70f 100644
--- a/modules/gpu/perf/perf_softcascade.cpp
+++ b/modules/gpu/perf/perf_softcascade.cpp
@@ -9,9 +9,9 @@
         virtual void __gpu();\
       virtual void PerfTestBody();\
     };\
-    TEST_P(fixture##_##name, name /*perf*/){ RunPerfTestBody(); if (PERF_RUN_GPU()) __gpu(); else __cpu();}\
+    TEST_P(fixture##_##name, name /*perf*/){ RunPerfTestBody(); }\
     INSTANTIATE_TEST_CASE_P(/*none*/, fixture##_##name, params);\
-    void fixture##_##name::PerfTestBody()
+    void fixture##_##name::PerfTestBody() { if (PERF_RUN_GPU()) __gpu(); else __cpu(); }
 
 #define RUN_CPU(fixture, name)\
     void fixture##_##name::__cpu()
@@ -56,7 +56,6 @@ GPU_PERF_TEST_P(SCascadeTest, detect,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
-{ }
 
 RUN_GPU(SCascadeTest, detect)
 {
@@ -114,7 +113,6 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectInRoi,
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 5)))
-{}
 
 RUN_GPU(SCascadeTestRoi, detectInRoi)
 {
@@ -159,7 +157,6 @@ GPU_PERF_TEST_P(SCascadeTestRoi, detectEachRoi,
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png")),
         testing::Range(0, 10)))
-{}
 
 RUN_GPU(SCascadeTestRoi, detectEachRoi)
 {
@@ -198,14 +195,13 @@ GPU_PERF_TEST_P(SCascadeTest, detectOnIntegral,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/integrals.xml"))))
-{ }
 
-    static std::string itoa(long i)
-    {
-        static char s[65];
-        sprintf(s, "%ld", i);
-        return std::string(s);
-    }
+static std::string itoa(long i)
+{
+    static char s[65];
+    sprintf(s, "%ld", i);
+    return std::string(s);
+}
 
 RUN_GPU(SCascadeTest, detectOnIntegral)
 {
@@ -247,7 +243,6 @@ GPU_PERF_TEST_P(SCascadeTest, detectStream,
     testing::Combine(
         testing::Values(std::string("cv/cascadeandhog/sc_cvpr_2012_to_opencv.xml")),
         testing::Values(std::string("cv/cascadeandhog/bahnhof/image_00000000_0.png"))))
-{ }
 
 RUN_GPU(SCascadeTest, detectStream)
 {
diff --git a/modules/ts/include/opencv2/ts/ts.hpp b/modules/ts/include/opencv2/ts/ts.hpp
index 061f53a82..094dad4da 100644
--- a/modules/ts/include/opencv2/ts/ts.hpp
+++ b/modules/ts/include/opencv2/ts/ts.hpp
@@ -1,7 +1,7 @@
 #ifndef __OPENCV_GTESTCV_HPP__
 #define __OPENCV_GTESTCV_HPP__
 
-#if HAVE_CVCONFIG_H
+#ifdef HAVE_CVCONFIG_H
 #include "cvconfig.h"
 #endif
 #ifndef GTEST_CREATE_SHARED_LIBRARY
diff --git a/modules/ts/src/ts_perf.cpp b/modules/ts/src/ts_perf.cpp
index 459e24f42..86336cf68 100644
--- a/modules/ts/src/ts_perf.cpp
+++ b/modules/ts/src/ts_perf.cpp
@@ -1,5 +1,9 @@
 #include "precomp.hpp"
 
+#ifdef HAVE_CUDA
+#include "opencv2/core/gpumat.hpp"
+#endif
+
 #ifdef ANDROID
 # include <sys/time.h>
 #endif
@@ -1145,6 +1149,10 @@ void TestBase::RunPerfTestBody()
     catch(cv::Exception e)
     {
         metrics.terminationReason = performance_metrics::TERM_EXCEPTION;
+        #ifdef HAVE_CUDA
+            if (e.code == CV_GpuApiCallError)
+                cv::gpu::resetDevice();
+        #endif
         FAIL() << "Expected: PerfTestBody() doesn't throw an exception.\n  Actual: it throws:\n  " << e.what();
     }
     catch(...)

From 11293d071fa3f0926bd44703a32e91541168cb0b Mon Sep 17 00:00:00 2001
From: vlad <vlad@vlad-VirtualBox.(none)>
Date: Thu, 20 Dec 2012 13:31:22 +0400
Subject: [PATCH 152/155] Revert "disabled video decoding under linux"

This reverts commit 889674ef43fb8d2a35883ae31895b34a58089007.
---
 modules/gpu/CMakeLists.txt              | 22 +++++++++++++++-------
 modules/gpu/perf/perf_video.cpp         |  6 +-----
 modules/gpu/src/cuvid_video_source.cpp  |  2 +-
 modules/gpu/src/cuvid_video_source.h    |  2 +-
 modules/gpu/src/ffmpeg_video_source.cpp |  2 +-
 modules/gpu/src/ffmpeg_video_source.h   |  2 +-
 modules/gpu/src/frame_queue.cpp         |  2 +-
 modules/gpu/src/frame_queue.h           |  2 +-
 modules/gpu/src/precomp.hpp             |  5 ++++-
 modules/gpu/src/thread_wrappers.cpp     |  2 +-
 modules/gpu/src/thread_wrappers.h       |  2 +-
 modules/gpu/src/video_decoder.cpp       |  2 +-
 modules/gpu/src/video_decoder.h         |  2 +-
 modules/gpu/src/video_parser.cpp        |  2 +-
 modules/gpu/src/video_parser.h          |  2 +-
 modules/gpu/src/video_reader.cpp        |  2 +-
 modules/gpu/test/test_video.cpp         | 10 +++++++---
 17 files changed, 40 insertions(+), 29 deletions(-)

diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 887daa917..1227b93a3 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -5,7 +5,7 @@ endif()
 set(the_description "GPU-accelerated Computer Vision")
 ocv_add_module(gpu opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree opencv_photo opencv_legacy)
 
-ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda" "${OpenCV_SOURCE_DIR}/modules/highgui/src")
+ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda" "${CMAKE_CURRENT_SOURCE_DIR}/../highgui/src")
 
 file(GLOB lib_hdrs               "include/opencv2/${name}/*.hpp"               "include/opencv2/${name}/*.h")
 file(GLOB lib_device_hdrs        "include/opencv2/${name}/device/*.hpp"        "include/opencv2/${name}/device/*.h")
@@ -21,16 +21,16 @@ source_group("Src\\Cuda"      FILES ${lib_cuda} ${lib_cuda_hdrs})
 source_group("Device"         FILES ${lib_device_hdrs})
 source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
-if(HAVE_CUDA)
+if (HAVE_CUDA)
   file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp" "src/nvidia/*.h*")
-  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")
+  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")  
   set(ncv_files ${ncv_srcs} ${ncv_cuda})
 
   source_group("Src\\NVidia" FILES ${ncv_files})
-
-  ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia" "${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia/core" "${CMAKE_CURRENT_SOURCE_DIR}/src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
+  ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations /wd4211 /wd4201 /wd4100 /wd4505 /wd4408)
-  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")  
+  #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
 
   if(MSVC)
     if(NOT ENABLE_NOISY_WARNINGS)
@@ -46,13 +46,21 @@ if(HAVE_CUDA)
 
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 
-  if(WIN32)
+  if(NOT APPLE)
+    unset(CUDA_nvcuvid_LIBRARY CACHE)
     find_cuda_helper_libs(nvcuvid)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvid_LIBRARY})
+  endif()
 
+  if(WIN32)
+    unset(CUDA_nvcuvenc_LIBRARY CACHE)
     find_cuda_helper_libs(nvcuvenc)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvenc_LIBRARY})
   endif()
+
+  if(NOT APPLE AND WITH_FFMPEG)
+    set(cuda_link_libs ${cuda_link_libs} ${HIGHGUI_LIBRARIES})
+  endif()
 else()
   set(lib_cuda "")
   set(cuda_objs "")
diff --git a/modules/gpu/perf/perf_video.cpp b/modules/gpu/perf/perf_video.cpp
index 5afe0d15f..bf2fd99c6 100644
--- a/modules/gpu/perf/perf_video.cpp
+++ b/modules/gpu/perf/perf_video.cpp
@@ -1045,12 +1045,10 @@ PERF_TEST_P(Video_Cn_MaxFeatures, DISABLED_Video_GMG,
     }
 }
 
-#ifdef WIN32
-
 //////////////////////////////////////////////////////
 // VideoWriter
 
-PERF_TEST_P(Video, Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
+PERF_TEST_P(Video, DISABLED_Video_VideoWriter, Values("gpu/video/768x576.avi", "gpu/video/1920x1080.avi"))
 {
     declare.time(30);
 
@@ -1147,6 +1145,4 @@ PERF_TEST_P(Video, Video_VideoReader, Values("gpu/video/768x576.avi", "gpu/video
     }
 }
 
-#endif
-
 } // namespace
diff --git a/modules/gpu/src/cuvid_video_source.cpp b/modules/gpu/src/cuvid_video_source.cpp
index 0700ba4cd..5c4691353 100644
--- a/modules/gpu/src/cuvid_video_source.cpp
+++ b/modules/gpu/src/cuvid_video_source.cpp
@@ -1,7 +1,7 @@
 #include "cuvid_video_source.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 cv::gpu::detail::CuvidVideoSource::CuvidVideoSource(const std::string& fname)
 {
diff --git a/modules/gpu/src/cuvid_video_source.h b/modules/gpu/src/cuvid_video_source.h
index b9c522cae..a06353fed 100644
--- a/modules/gpu/src/cuvid_video_source.h
+++ b/modules/gpu/src/cuvid_video_source.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/ffmpeg_video_source.cpp b/modules/gpu/src/ffmpeg_video_source.cpp
index fe9771554..7538de601 100644
--- a/modules/gpu/src/ffmpeg_video_source.cpp
+++ b/modules/gpu/src/ffmpeg_video_source.cpp
@@ -42,7 +42,7 @@
 
 #include "ffmpeg_video_source.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 #if defined(HAVE_FFMPEG) && defined(BUILD_SHARED_LIBS)
     #include "cap_ffmpeg_impl.hpp"
diff --git a/modules/gpu/src/ffmpeg_video_source.h b/modules/gpu/src/ffmpeg_video_source.h
index 9ec5559c5..66bb7c71c 100644
--- a/modules/gpu/src/ffmpeg_video_source.h
+++ b/modules/gpu/src/ffmpeg_video_source.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 struct InputMediaStream_FFMPEG;
 
diff --git a/modules/gpu/src/frame_queue.cpp b/modules/gpu/src/frame_queue.cpp
index 5f0659c7b..4ed6d0f14 100644
--- a/modules/gpu/src/frame_queue.cpp
+++ b/modules/gpu/src/frame_queue.cpp
@@ -42,7 +42,7 @@
 
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 cv::gpu::detail::FrameQueue::FrameQueue() :
     endOfDecode_(0),
diff --git a/modules/gpu/src/frame_queue.h b/modules/gpu/src/frame_queue.h
index dc3da7336..5c049a28e 100644
--- a/modules/gpu/src/frame_queue.h
+++ b/modules/gpu/src/frame_queue.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/precomp.hpp b/modules/gpu/src/precomp.hpp
index 9310e69f1..c37332ae4 100644
--- a/modules/gpu/src/precomp.hpp
+++ b/modules/gpu/src/precomp.hpp
@@ -97,8 +97,11 @@
         #include <cublas.h>
     #endif
 
-    #ifdef WIN32
+    #ifndef __APPLE__
         #include <nvcuvid.h>
+    #endif
+
+    #ifdef WIN32
         #include <NVEncoderAPI.h>
     #endif
 
diff --git a/modules/gpu/src/thread_wrappers.cpp b/modules/gpu/src/thread_wrappers.cpp
index e88b79243..fcfa59827 100644
--- a/modules/gpu/src/thread_wrappers.cpp
+++ b/modules/gpu/src/thread_wrappers.cpp
@@ -42,7 +42,7 @@
 
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 #ifdef WIN32
     #define NOMINMAX
diff --git a/modules/gpu/src/thread_wrappers.h b/modules/gpu/src/thread_wrappers.h
index 6d6e87c5e..9198d3e90 100644
--- a/modules/gpu/src/thread_wrappers.h
+++ b/modules/gpu/src/thread_wrappers.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_decoder.cpp b/modules/gpu/src/video_decoder.cpp
index bba28af86..41e1d2607 100644
--- a/modules/gpu/src/video_decoder.cpp
+++ b/modules/gpu/src/video_decoder.cpp
@@ -43,7 +43,7 @@
 #include "video_decoder.h"
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 void cv::gpu::detail::VideoDecoder::create(const VideoReader_GPU::FormatInfo& videoFormat)
 {
diff --git a/modules/gpu/src/video_decoder.h b/modules/gpu/src/video_decoder.h
index 0b638a0c6..9c4dfa929 100644
--- a/modules/gpu/src/video_decoder.h
+++ b/modules/gpu/src/video_decoder.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_parser.cpp b/modules/gpu/src/video_parser.cpp
index 78f1efe82..2ff14bd75 100644
--- a/modules/gpu/src/video_parser.cpp
+++ b/modules/gpu/src/video_parser.cpp
@@ -43,7 +43,7 @@
 #include "video_parser.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 cv::gpu::detail::VideoParser::VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue) :
     videoDecoder_(videoDecoder), frameQueue_(frameQueue), unparsedPackets_(0), hasError_(false)
diff --git a/modules/gpu/src/video_parser.h b/modules/gpu/src/video_parser.h
index c3c2d1c61..3935ffcef 100644
--- a/modules/gpu/src/video_parser.h
+++ b/modules/gpu/src/video_parser.h
@@ -48,7 +48,7 @@
 #include "frame_queue.h"
 #include "video_decoder.h"
 
-#if defined(HAVE_CUDA) && defined(WIN32)
+#if defined(HAVE_CUDA) && !defined(__APPLE__)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_reader.cpp b/modules/gpu/src/video_reader.cpp
index d9294d861..df3c2ff2f 100644
--- a/modules/gpu/src/video_reader.cpp
+++ b/modules/gpu/src/video_reader.cpp
@@ -42,7 +42,7 @@
 
 #include "precomp.hpp"
 
-#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || !defined(WIN32)
+#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || defined(__APPLE__)
 
 class cv::gpu::VideoReader_GPU::Impl
 {
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 4cbbf0bf8..424bdbd3b 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -43,11 +43,11 @@
 
 #ifdef HAVE_CUDA
 
-#ifdef WIN32
-
 //////////////////////////////////////////////////////
 // VideoWriter
 
+#ifdef WIN32
+
 PARAM_TEST_CASE(VideoWriter, cv::gpu::DeviceInfo, std::string)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -107,9 +107,13 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
     ALL_DEVICES,
     testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
 
+#endif // WIN32
+
 //////////////////////////////////////////////////////
 // VideoReader
 
+#ifdef HAVE_NVCUVID
+
 PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
 {
     cv::gpu::DeviceInfo devInfo;
@@ -147,6 +151,6 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
     ALL_DEVICES,
     testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
 
-#endif // WIN32
+#endif // HAVE_NVCUVID
 
 #endif // HAVE_CUDA

From 2f1ca1b6b3d160cb0e93c27d8b2fc419c7ce04f3 Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Thu, 20 Dec 2012 16:19:14 +0400
Subject: [PATCH 153/155] fixed build for CARMA:

* added CMake toolchain file
* added WITH_NVCUVID flag
---
 CMakeLists.txt                          | 49 +++++++-------
 cmake/OpenCVDetectCUDA.cmake            | 25 ++++---
 cmake/templates/cvconfig.h.cmake        | 21 +++---
 modules/gpu/CMakeLists.txt              |  7 +-
 modules/gpu/misc/carma.toolchain.cmake  | 10 +++
 modules/gpu/src/cuvid_video_source.cpp  |  2 +-
 modules/gpu/src/cuvid_video_source.h    |  2 +-
 modules/gpu/src/ffmpeg_video_source.cpp |  2 +-
 modules/gpu/src/ffmpeg_video_source.h   |  2 +-
 modules/gpu/src/frame_queue.cpp         |  2 +-
 modules/gpu/src/frame_queue.h           |  2 +-
 modules/gpu/src/precomp.hpp             |  8 +--
 modules/gpu/src/thread_wrappers.cpp     |  2 +-
 modules/gpu/src/thread_wrappers.h       |  2 +-
 modules/gpu/src/video_decoder.cpp       |  2 +-
 modules/gpu/src/video_decoder.h         |  2 +-
 modules/gpu/src/video_parser.cpp        |  2 +-
 modules/gpu/src/video_parser.h          |  2 +-
 modules/gpu/src/video_reader.cpp        |  2 +-
 modules/gpu/src/video_writer.cpp        |  4 +-
 modules/gpu/test/test_video.cpp         | 88 ++++++++++++-------------
 21 files changed, 127 insertions(+), 111 deletions(-)
 create mode 100644 modules/gpu/misc/carma.toolchain.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 949ca43c6..091bc2255 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -110,43 +110,44 @@ endif()
 
 # Optional 3rd party components
 # ===================================================
-OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (UNIX AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (UNIX AND NOT ANDROID AND NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_AVFOUNDATION   "Use AVFoundation for Video I/O"              ON   IF IOS)
 OCV_OPTION(WITH_CARBON         "Use Carbon for UI instead of Cocoa"          OFF  IF APPLE )
-OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"         ON   IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_NVCUVID        "Include NVidia Video Decoding library support"                               OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS AND NOT APPLE) )
 OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON)
-OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
-OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
+OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
 OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   OFF  IF (MSVC OR X86 OR X86_64) )
 OCV_OPTION(WITH_JASPER         "Include JPEG2K support"                      ON   IF (NOT IOS) )
 OCV_OPTION(WITH_JPEG           "Include JPEG support"                        ON   IF (NOT IOS) )
 OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE) )
-OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE AND NOT CARMA) )
+OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON   IF (NOT IOS) )
-OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_QUICKTIME      "Use QuickTime for Video I/O insted of QTKit" OFF  IF APPLE )
-OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS) )
+OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_CSTRIPES       "Include C= support"                          OFF  IF WIN32 )
 OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON   IF (NOT IOS) )
-OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
-OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
+OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
 OCV_OPTION(WITH_VIDEOINPUT     "Build HighGUI with DirectShow support"       ON   IF WIN32 )
-OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
-OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE AND NOT CARMA) )
+OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
-OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS) )
-OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF  IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
 
 
 # OpenCV build components
 # ===================================================
-OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS) )
+OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS OR CARMA) )
 OCV_OPTION(BUILD_ANDROID_EXAMPLES   "Build examples for Android platform"         ON  IF ANDROID )
 OCV_OPTION(BUILD_DOCS               "Create build rules for OpenCV Documentation" ON )
 OCV_OPTION(BUILD_EXAMPLES           "Build all examples"                          OFF )
@@ -160,12 +161,12 @@ OCV_OPTION(BUILD_ANDROID_SERVICE    "Build OpenCV Manager for Google Play" OFF I
 OCV_OPTION(BUILD_ANDROID_PACKAGE    "Build platform-specific package for Google Play" OFF IF ANDROID )
 
 # 3rd party libs
-OCV_OPTION(BUILD_ZLIB               "Build zlib from source"         WIN32 OR APPLE )
-OCV_OPTION(BUILD_TIFF               "Build libtiff from source"      WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_JASPER             "Build libjasper from source"    WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_JPEG               "Build libjpeg from source"      WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_PNG                "Build libpng from source"       WIN32 OR ANDROID OR APPLE )
-OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"      WIN32 OR ANDROID OR APPLE )
+OCV_OPTION(BUILD_ZLIB               "Build zlib from source"         WIN32 OR APPLE OR CARMA )
+OCV_OPTION(BUILD_TIFF               "Build libtiff from source"      WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_JASPER             "Build libjasper from source"    WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_JPEG               "Build libjpeg from source"      WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_PNG                "Build libpng from source"       WIN32 OR ANDROID OR APPLE OR CARMA )
+OCV_OPTION(BUILD_OPENEXR            "Build openexr from source"      WIN32 OR ANDROID OR APPLE OR CARMA )
 
 
 # OpenCV installation options
diff --git a/cmake/OpenCVDetectCUDA.cmake b/cmake/OpenCVDetectCUDA.cmake
index 354ffbf99..da06b8977 100644
--- a/cmake/OpenCVDetectCUDA.cmake
+++ b/cmake/OpenCVDetectCUDA.cmake
@@ -13,7 +13,7 @@ if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Cl
   return()
 endif()
 
-find_package(CUDA 4.1)
+find_package(CUDA 4.2)
 
 if(CUDA_FOUND)
   set(HAVE_CUDA 1)
@@ -26,15 +26,20 @@ if(CUDA_FOUND)
     set(HAVE_CUBLAS 1)
   endif()
 
-  message(STATUS "CUDA detected: " ${CUDA_VERSION})
-
-  if(${CUDA_VERSION_STRING} VERSION_GREATER "4.1")
-    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0) 3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
-  else()
-    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0)" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+  if(WITH_NVCUVID)
+    find_cuda_helper_libs(nvcuvid)
+    set(HAVE_NVCUVID 1)
   endif()
 
-  set(CUDA_ARCH_PTX "2.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  message(STATUS "CUDA detected: " ${CUDA_VERSION})
+
+  if (CARMA)
+    set(CUDA_ARCH_BIN "3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+    set(CUDA_ARCH_PTX "3.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  else()
+    set(CUDA_ARCH_BIN "1.1 1.2 1.3 2.0 2.1(2.0) 3.0" CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
+    set(CUDA_ARCH_PTX "2.0 3.0" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
+  endif()
 
   string(REGEX REPLACE "\\." "" ARCH_BIN_NO_POINTS "${CUDA_ARCH_BIN}")
   string(REGEX REPLACE "\\." "" ARCH_PTX_NO_POINTS "${CUDA_ARCH_PTX}")
@@ -78,6 +83,10 @@ if(CUDA_FOUND)
     set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
   endforeach()
 
+  if(CARMA)
+    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --target-cpu-architecture=ARM "-ccbin=${CMAKE_CXX_COMPILER}")
+  endif()
+
   # These vars will be processed in other scripts
   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} ${NVCC_FLAGS_EXTRA})
   set(OpenCV_CUDA_CC "${NVCC_FLAGS_EXTRA}")
diff --git a/cmake/templates/cvconfig.h.cmake b/cmake/templates/cvconfig.h.cmake
index 37e092b66..6d4d2184f 100644
--- a/cmake/templates/cvconfig.h.cmake
+++ b/cmake/templates/cvconfig.h.cmake
@@ -172,21 +172,15 @@
 /* NVidia Cuda Runtime API*/
 #cmakedefine HAVE_CUDA
 
-/* OpenCL Support */
-#cmakedefine HAVE_OPENCL
-
-/* AMD's OpenCL Fast Fourier Transform Library*/
-#cmakedefine HAVE_CLAMDFFT
-
-/* AMD's Basic Linear Algebra Subprograms Library*/
-#cmakedefine HAVE_CLAMDBLAS
-
 /* NVidia Cuda Fast Fourier Transform (FFT) API*/
 #cmakedefine HAVE_CUFFT
 
 /* NVidia Cuda Basic Linear Algebra Subprograms (BLAS) API*/
 #cmakedefine HAVE_CUBLAS
 
+/* NVidia Video Decoding API*/
+#cmakedefine HAVE_NVCUVID
+
 /* Compile for 'real' NVIDIA GPU architectures */
 #define CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN}"
 
@@ -199,6 +193,15 @@
 /* Create PTX or BIN for 1.0 compute capability */
 #cmakedefine CUDA_ARCH_BIN_OR_PTX_10
 
+/* OpenCL Support */
+#cmakedefine HAVE_OPENCL
+
+/* AMD's OpenCL Fast Fourier Transform Library*/
+#cmakedefine HAVE_CLAMDFFT
+
+/* AMD's Basic Linear Algebra Subprograms Library*/
+#cmakedefine HAVE_CLAMDBLAS
+
 /* VideoInput library */
 #cmakedefine HAVE_VIDEOINPUT
 
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index 1227b93a3..ff9d0fda9 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -46,19 +46,16 @@ if (HAVE_CUDA)
 
   set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 
-  if(NOT APPLE)
-    unset(CUDA_nvcuvid_LIBRARY CACHE)
-    find_cuda_helper_libs(nvcuvid)
+  if(WITH_NVCUVID)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvid_LIBRARY})
   endif()
 
   if(WIN32)
-    unset(CUDA_nvcuvenc_LIBRARY CACHE)
     find_cuda_helper_libs(nvcuvenc)
     set(cuda_link_libs ${cuda_link_libs} ${CUDA_nvcuvenc_LIBRARY})
   endif()
 
-  if(NOT APPLE AND WITH_FFMPEG)
+  if(WITH_FFMPEG)
     set(cuda_link_libs ${cuda_link_libs} ${HIGHGUI_LIBRARIES})
   endif()
 else()
diff --git a/modules/gpu/misc/carma.toolchain.cmake b/modules/gpu/misc/carma.toolchain.cmake
new file mode 100644
index 000000000..a5531f44b
--- /dev/null
+++ b/modules/gpu/misc/carma.toolchain.cmake
@@ -0,0 +1,10 @@
+set(CMAKE_SYSTEM_NAME Linux)
+SET(CMAKE_SYSTEM_VERSION 1)
+
+set(CMAKE_C_COMPILER /usr/bin/arm-linux-gnueabi-gcc-4.5)
+set(CMAKE_CXX_COMPILER /usr/bin/arm-linux-gnueabi-g++-4.5)
+
+SET(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabi)
+
+set(CARMA 1)
+add_definitions(-DCARMA)
diff --git a/modules/gpu/src/cuvid_video_source.cpp b/modules/gpu/src/cuvid_video_source.cpp
index 5c4691353..7d45b8fee 100644
--- a/modules/gpu/src/cuvid_video_source.cpp
+++ b/modules/gpu/src/cuvid_video_source.cpp
@@ -1,7 +1,7 @@
 #include "cuvid_video_source.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 cv::gpu::detail::CuvidVideoSource::CuvidVideoSource(const std::string& fname)
 {
diff --git a/modules/gpu/src/cuvid_video_source.h b/modules/gpu/src/cuvid_video_source.h
index a06353fed..1c4c0e5e0 100644
--- a/modules/gpu/src/cuvid_video_source.h
+++ b/modules/gpu/src/cuvid_video_source.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/ffmpeg_video_source.cpp b/modules/gpu/src/ffmpeg_video_source.cpp
index 7538de601..42327fef3 100644
--- a/modules/gpu/src/ffmpeg_video_source.cpp
+++ b/modules/gpu/src/ffmpeg_video_source.cpp
@@ -42,7 +42,7 @@
 
 #include "ffmpeg_video_source.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 #if defined(HAVE_FFMPEG) && defined(BUILD_SHARED_LIBS)
     #include "cap_ffmpeg_impl.hpp"
diff --git a/modules/gpu/src/ffmpeg_video_source.h b/modules/gpu/src/ffmpeg_video_source.h
index 66bb7c71c..41bf0cfd0 100644
--- a/modules/gpu/src/ffmpeg_video_source.h
+++ b/modules/gpu/src/ffmpeg_video_source.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 struct InputMediaStream_FFMPEG;
 
diff --git a/modules/gpu/src/frame_queue.cpp b/modules/gpu/src/frame_queue.cpp
index 4ed6d0f14..0d9391873 100644
--- a/modules/gpu/src/frame_queue.cpp
+++ b/modules/gpu/src/frame_queue.cpp
@@ -42,7 +42,7 @@
 
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 cv::gpu::detail::FrameQueue::FrameQueue() :
     endOfDecode_(0),
diff --git a/modules/gpu/src/frame_queue.h b/modules/gpu/src/frame_queue.h
index 5c049a28e..00c44a401 100644
--- a/modules/gpu/src/frame_queue.h
+++ b/modules/gpu/src/frame_queue.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/precomp.hpp b/modules/gpu/src/precomp.hpp
index c37332ae4..7c5318510 100644
--- a/modules/gpu/src/precomp.hpp
+++ b/modules/gpu/src/precomp.hpp
@@ -97,12 +97,12 @@
         #include <cublas.h>
     #endif
 
-    #ifndef __APPLE__
+    #ifdef HAVE_NVCUVID
         #include <nvcuvid.h>
-    #endif
 
-    #ifdef WIN32
-        #include <NVEncoderAPI.h>
+        #ifdef WIN32
+            #include <NVEncoderAPI.h>
+        #endif
     #endif
 
     #include "internal_shared.hpp"
diff --git a/modules/gpu/src/thread_wrappers.cpp b/modules/gpu/src/thread_wrappers.cpp
index fcfa59827..f8099aca9 100644
--- a/modules/gpu/src/thread_wrappers.cpp
+++ b/modules/gpu/src/thread_wrappers.cpp
@@ -42,7 +42,7 @@
 
 #include "thread_wrappers.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 #ifdef WIN32
     #define NOMINMAX
diff --git a/modules/gpu/src/thread_wrappers.h b/modules/gpu/src/thread_wrappers.h
index 9198d3e90..78e675216 100644
--- a/modules/gpu/src/thread_wrappers.h
+++ b/modules/gpu/src/thread_wrappers.h
@@ -45,7 +45,7 @@
 
 #include "precomp.hpp"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_decoder.cpp b/modules/gpu/src/video_decoder.cpp
index 41e1d2607..c1e8f86a4 100644
--- a/modules/gpu/src/video_decoder.cpp
+++ b/modules/gpu/src/video_decoder.cpp
@@ -43,7 +43,7 @@
 #include "video_decoder.h"
 #include "frame_queue.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 void cv::gpu::detail::VideoDecoder::create(const VideoReader_GPU::FormatInfo& videoFormat)
 {
diff --git a/modules/gpu/src/video_decoder.h b/modules/gpu/src/video_decoder.h
index 9c4dfa929..634643b88 100644
--- a/modules/gpu/src/video_decoder.h
+++ b/modules/gpu/src/video_decoder.h
@@ -46,7 +46,7 @@
 #include "precomp.hpp"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_parser.cpp b/modules/gpu/src/video_parser.cpp
index 2ff14bd75..70187fcb2 100644
--- a/modules/gpu/src/video_parser.cpp
+++ b/modules/gpu/src/video_parser.cpp
@@ -43,7 +43,7 @@
 #include "video_parser.h"
 #include "cu_safe_call.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 cv::gpu::detail::VideoParser::VideoParser(VideoDecoder* videoDecoder, FrameQueue* frameQueue) :
     videoDecoder_(videoDecoder), frameQueue_(frameQueue), unparsedPackets_(0), hasError_(false)
diff --git a/modules/gpu/src/video_parser.h b/modules/gpu/src/video_parser.h
index 3935ffcef..44a53710b 100644
--- a/modules/gpu/src/video_parser.h
+++ b/modules/gpu/src/video_parser.h
@@ -48,7 +48,7 @@
 #include "frame_queue.h"
 #include "video_decoder.h"
 
-#if defined(HAVE_CUDA) && !defined(__APPLE__)
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
 
 namespace cv { namespace gpu
 {
diff --git a/modules/gpu/src/video_reader.cpp b/modules/gpu/src/video_reader.cpp
index df3c2ff2f..3224902c6 100644
--- a/modules/gpu/src/video_reader.cpp
+++ b/modules/gpu/src/video_reader.cpp
@@ -42,7 +42,7 @@
 
 #include "precomp.hpp"
 
-#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || defined(__APPLE__)
+#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) || !defined(HAVE_NVCUVID)
 
 class cv::gpu::VideoReader_GPU::Impl
 {
diff --git a/modules/gpu/src/video_writer.cpp b/modules/gpu/src/video_writer.cpp
index 617c1eabc..dd4b8fb03 100644
--- a/modules/gpu/src/video_writer.cpp
+++ b/modules/gpu/src/video_writer.cpp
@@ -42,7 +42,7 @@
 
 #include "precomp.hpp"
 
-#if !defined HAVE_CUDA || defined(CUDA_DISABLER) || !defined(WIN32)
+#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) || !defined(HAVE_NVCUVID) || !defined(WIN32)
 
 class cv::gpu::VideoWriter_GPU::Impl
 {
@@ -1001,4 +1001,4 @@ void cv::gpu::VideoWriter_GPU::EncoderParams::save(const std::string& configFile
     cv::write(fs, "DisableSPSPPS"  , DisableSPSPPS);
 }
 
-#endif // !defined HAVE_CUDA || !defined WIN32
\ No newline at end of file
+#endif // !defined HAVE_CUDA || !defined WIN32
diff --git a/modules/gpu/test/test_video.cpp b/modules/gpu/test/test_video.cpp
index 424bdbd3b..b9502814a 100644
--- a/modules/gpu/test/test_video.cpp
+++ b/modules/gpu/test/test_video.cpp
@@ -41,7 +41,47 @@
 
 #include "test_precomp.hpp"
 
-#ifdef HAVE_CUDA
+#if defined(HAVE_CUDA) && defined(HAVE_NVCUVID)
+
+//////////////////////////////////////////////////////
+// VideoReader
+
+PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
+{
+    cv::gpu::DeviceInfo devInfo;
+    std::string inputFile;
+
+    virtual void SetUp()
+    {
+        devInfo = GET_PARAM(0);
+        inputFile = GET_PARAM(1);
+
+        cv::gpu::setDevice(devInfo.deviceID());
+
+        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + inputFile;
+    }
+};
+
+GPU_TEST_P(VideoReader, Regression)
+{
+    cv::gpu::VideoReader_GPU reader(inputFile);
+    ASSERT_TRUE(reader.isOpened());
+
+    cv::gpu::GpuMat frame;
+
+    for (int i = 0; i < 10; ++i)
+    {
+        ASSERT_TRUE(reader.read(frame));
+        ASSERT_FALSE(frame.empty());
+    }
+
+    reader.close();
+    ASSERT_FALSE(reader.isOpened());
+}
+
+INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
+    ALL_DEVICES,
+    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
 
 //////////////////////////////////////////////////////
 // VideoWriter
@@ -109,48 +149,4 @@ INSTANTIATE_TEST_CASE_P(GPU_Video, VideoWriter, testing::Combine(
 
 #endif // WIN32
 
-//////////////////////////////////////////////////////
-// VideoReader
-
-#ifdef HAVE_NVCUVID
-
-PARAM_TEST_CASE(VideoReader, cv::gpu::DeviceInfo, std::string)
-{
-    cv::gpu::DeviceInfo devInfo;
-    std::string inputFile;
-
-    virtual void SetUp()
-    {
-        devInfo = GET_PARAM(0);
-        inputFile = GET_PARAM(1);
-
-        cv::gpu::setDevice(devInfo.deviceID());
-
-        inputFile = std::string(cvtest::TS::ptr()->get_data_path()) + "video/" + inputFile;
-    }
-};
-
-GPU_TEST_P(VideoReader, Regression)
-{
-    cv::gpu::VideoReader_GPU reader(inputFile);
-    ASSERT_TRUE(reader.isOpened());
-
-    cv::gpu::GpuMat frame;
-
-    for (int i = 0; i < 10; ++i)
-    {
-        ASSERT_TRUE(reader.read(frame));
-        ASSERT_FALSE(frame.empty());
-    }
-
-    reader.close();
-    ASSERT_FALSE(reader.isOpened());
-}
-
-INSTANTIATE_TEST_CASE_P(GPU_Video, VideoReader, testing::Combine(
-    ALL_DEVICES,
-    testing::Values(std::string("768x576.avi"), std::string("1920x1080.avi"))));
-
-#endif // HAVE_NVCUVID
-
-#endif // HAVE_CUDA
+#endif //  defined(HAVE_CUDA) && defined(HAVE_NVCUVID)

From 4db68b50f289abb0de9eca0bf99c1ea9b3bffbeb Mon Sep 17 00:00:00 2001
From: Vladislav Vinogradov <vlad.vinogradov@itseez.com>
Date: Sun, 23 Dec 2012 14:21:16 +0400
Subject: [PATCH 154/155] fixed Sobel and Scharr tests

compare inner part
---
 modules/gpu/test/test_filters.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/gpu/test/test_filters.cpp b/modules/gpu/test/test_filters.cpp
index 779a6d7c4..f6ae4067a 100644
--- a/modules/gpu/test/test_filters.cpp
+++ b/modules/gpu/test/test_filters.cpp
@@ -158,7 +158,7 @@ GPU_TEST_P(Sobel, Accuracy)
     cv::Mat dst_gold;
     cv::Sobel(src, dst_gold, -1, dx, dy, ksize.width, 1.0, 0.0, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, ksize), getInnerROI(dst, ksize), CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Sobel, testing::Combine(
@@ -221,7 +221,7 @@ GPU_TEST_P(Scharr, Accuracy)
     cv::Mat dst_gold;
     cv::Scharr(src, dst_gold, -1, dx, dy, 1.0, 0.0, borderType);
 
-    EXPECT_MAT_NEAR(dst_gold, dst, CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
+    EXPECT_MAT_NEAR(getInnerROI(dst_gold, cv::Size(3, 3)), getInnerROI(dst, cv::Size(3, 3)), CV_MAT_DEPTH(type) < CV_32F ? 0.0 : 0.1);
 }
 
 INSTANTIATE_TEST_CASE_P(GPU_Filter, Scharr, testing::Combine(

From 3882bbbf35f1bcd8fa76bf70875dd808e14dcd16 Mon Sep 17 00:00:00 2001
From: "marina.kolpakova" <marina.kolpakova@itseez.com>
Date: Mon, 24 Dec 2012 14:51:47 +0400
Subject: [PATCH 155/155] improve carma build  - exclude system paths from
 library search paths  - remove hardcoded paths to compiler  - enable
 compiling with 3d-parties  - enable build as shared libraries

---
 CMakeLists.txt                         | 26 +++++++++++++-------------
 cmake/OpenCVDetectCUDA.cmake           |  7 ++++++-
 modules/gpu/CMakeLists.txt             |  4 ++--
 modules/gpu/misc/carma.toolchain.cmake | 24 ++++++++++++++++++++----
 4 files changed, 41 insertions(+), 20 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a5934eadc..9b7f532ac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -118,27 +118,27 @@ OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT)
 OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_NVCUVID        "Include NVidia Video Decoding library support"                               OFF IF (CMAKE_VERSION VERSION_GREATER "2.8" AND NOT ANDROID AND NOT IOS AND NOT APPLE) )
 OCV_OPTION(WITH_EIGEN          "Include Eigen2/Eigen3 support"               ON)
-OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
-OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
-OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
+OCV_OPTION(WITH_FFMPEG         "Include FFMPEG support"                      ON   IF (NOT ANDROID AND NOT IOS))
+OCV_OPTION(WITH_GSTREAMER      "Include Gstreamer support"                   ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_GTK            "Include GTK support"                         ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_IPP            "Include Intel IPP support"                   OFF  IF (MSVC OR X86 OR X86_64) )
 OCV_OPTION(WITH_JASPER         "Include JPEG2K support"                      ON   IF (NOT IOS) )
 OCV_OPTION(WITH_JPEG           "Include JPEG support"                        ON   IF (NOT IOS) )
 OCV_OPTION(WITH_OPENEXR        "Include ILM support via OpenEXR"             ON   IF (NOT IOS) )
-OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE AND NOT CARMA) )
-OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_OPENGL         "Include OpenGL support"                      OFF  IF (NOT ANDROID AND NOT APPLE) )
+OCV_OPTION(WITH_OPENNI         "Include OpenNI support"                      OFF  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_PNG            "Include PNG support"                         ON   IF (NOT IOS) )
-OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
-OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_PVAPI          "Include Prosilica GigE support"              ON   IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_QT             "Build with Qt Backend support"               OFF  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_QUICKTIME      "Use QuickTime for Video I/O insted of QTKit" OFF  IF APPLE )
-OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS AND NOT CARMA) )
+OCV_OPTION(WITH_TBB            "Include Intel TBB support"                   OFF  IF (NOT IOS) )
 OCV_OPTION(WITH_CSTRIPES       "Include C= support"                          OFF  IF WIN32 )
 OCV_OPTION(WITH_TIFF           "Include TIFF support"                        ON   IF (NOT IOS) )
-OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
-OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
+OCV_OPTION(WITH_UNICAP         "Include Unicap support (GPL)"                OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
+OCV_OPTION(WITH_V4L            "Include Video 4 Linux support"               ON   IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_VIDEOINPUT     "Build HighGUI with DirectShow support"       ON   IF WIN32 )
-OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE AND NOT CARMA) )
-OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID AND NOT CARMA) )
+OCV_OPTION(WITH_XIMEA          "Include XIMEA cameras support"               OFF  IF (NOT ANDROID AND NOT APPLE) )
+OCV_OPTION(WITH_XINE           "Include Xine support (GPL)"                  OFF  IF (UNIX AND NOT APPLE AND NOT ANDROID) )
 OCV_OPTION(WITH_CLP            "Include Clp support (EPL)"                   OFF)
 OCV_OPTION(WITH_OPENCL         "Include OpenCL Runtime support"              OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
 OCV_OPTION(WITH_OPENCLAMDFFT   "Include AMD OpenCL FFT library support"      OFF  IF (NOT ANDROID AND NOT IOS AND NOT CARMA) )
@@ -147,7 +147,7 @@ OCV_OPTION(WITH_OPENCLAMDBLAS  "Include AMD OpenCL BLAS library support"     OFF
 
 # OpenCV build components
 # ===================================================
-OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS OR CARMA) )
+OCV_OPTION(BUILD_SHARED_LIBS        "Build shared libraries (.dll/.so) instead of static ones (.lib/.a)" NOT (ANDROID OR IOS) )
 OCV_OPTION(BUILD_ANDROID_EXAMPLES   "Build examples for Android platform"         ON  IF ANDROID )
 OCV_OPTION(BUILD_DOCS               "Create build rules for OpenCV Documentation" ON )
 OCV_OPTION(BUILD_EXAMPLES           "Build all examples"                          OFF )
diff --git a/cmake/OpenCVDetectCUDA.cmake b/cmake/OpenCVDetectCUDA.cmake
index da06b8977..d6d5f3a98 100644
--- a/cmake/OpenCVDetectCUDA.cmake
+++ b/cmake/OpenCVDetectCUDA.cmake
@@ -84,7 +84,12 @@ if(CUDA_FOUND)
   endforeach()
 
   if(CARMA)
-    set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --target-cpu-architecture=ARM "-ccbin=${CMAKE_CXX_COMPILER}")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} --target-cpu-architecture=ARM" )
+
+    if (CMAKE_VERSION VERSION_LESS 2.8.10)
+      set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -ccbin=${CMAKE_CXX_COMPILER}" )
+    endif()
+
   endif()
 
   # These vars will be processed in other scripts
diff --git a/modules/gpu/CMakeLists.txt b/modules/gpu/CMakeLists.txt
index ff9d0fda9..2f62826dd 100644
--- a/modules/gpu/CMakeLists.txt
+++ b/modules/gpu/CMakeLists.txt
@@ -23,13 +23,13 @@ source_group("Device\\Detail" FILES ${lib_device_hdrs_detail})
 
 if (HAVE_CUDA)
   file(GLOB_RECURSE ncv_srcs "src/nvidia/*.cpp" "src/nvidia/*.h*")
-  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")  
+  file(GLOB_RECURSE ncv_cuda "src/nvidia/*.cu")
   set(ncv_files ${ncv_srcs} ${ncv_cuda})
 
   source_group("Src\\NVidia" FILES ${ncv_files})
   ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
   ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef -Wmissing-declarations /wd4211 /wd4201 /wd4100 /wd4505 /wd4408)
-  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")  
+  string(REPLACE "-Wsign-promo" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
 
   if(MSVC)
diff --git a/modules/gpu/misc/carma.toolchain.cmake b/modules/gpu/misc/carma.toolchain.cmake
index a5531f44b..18f0e0f93 100644
--- a/modules/gpu/misc/carma.toolchain.cmake
+++ b/modules/gpu/misc/carma.toolchain.cmake
@@ -1,10 +1,26 @@
 set(CMAKE_SYSTEM_NAME Linux)
-SET(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_VERSION 1)
+set(CMAKE_SYSTEM_PROCESSOR arm)
 
-set(CMAKE_C_COMPILER /usr/bin/arm-linux-gnueabi-gcc-4.5)
-set(CMAKE_CXX_COMPILER /usr/bin/arm-linux-gnueabi-g++-4.5)
+set(CMAKE_C_COMPILER    arm-linux-gnueabi-gcc-4.5)
+set(CMAKE_CXX_COMPILER  arm-linux-gnueabi-g++-4.5)
 
-SET(CMAKE_FIND_ROOT_PATH /usr/arm-linux-gnueabi)
+#suppress compiller varning
+set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-psabi" )
+set( CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -Wno-psabi" )
+
+# can be any other plases
+set(__arm_linux_eabi_root /usr/arm-linux-gnueabi)
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${__arm_linux_eabi_root})
+
+if(EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
+    set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CUDA_TOOLKIT_ROOT_DIR})
+endif()
+
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
 
 set(CARMA 1)
 add_definitions(-DCARMA)